LCOV - code coverage report
Current view: top level - MapServer/build/mapscript/python/CMakeFiles/_pythonmapscript.dir - mapscriptPYTHON_wrap.c (source / functions) Hit Total Coverage
Test: mapserver.info Lines: 6176 24030 25.7 %
Date: 2020-12-13 18:03:20 Functions: 479 1305 36.7 %

          Line data    Source code
       1             : /* ----------------------------------------------------------------------------
       2             :  * This file was automatically generated by SWIG (http://www.swig.org).
       3             :  * Version 3.0.12
       4             :  *
       5             :  * This file is not intended to be easily readable and contains a number of
       6             :  * coding conventions designed to improve portability and efficiency. Do not make
       7             :  * changes to this file unless you know what you are doing--modify the SWIG
       8             :  * interface file instead.
       9             :  * ----------------------------------------------------------------------------- */
      10             : 
      11             : #ifdef _MSC_VER
      12             : #define SWIG_PYTHON_INTERPRETER_NO_DEBUG
      13             : #else
      14             : #define _GNU_SOURCE 1
      15             : #endif
      16             : 
      17             : 
      18             : 
      19             : #ifndef SWIGPYTHON
      20             : #define SWIGPYTHON
      21             : #endif
      22             : 
      23             : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
      24             : 
      25             : /* -----------------------------------------------------------------------------
      26             :  *  This section contains generic SWIG labels for method/variable
      27             :  *  declarations/attributes, and other compiler dependent labels.
      28             :  * ----------------------------------------------------------------------------- */
      29             : 
      30             : /* template workaround for compilers that cannot correctly implement the C++ standard */
      31             : #ifndef SWIGTEMPLATEDISAMBIGUATOR
      32             : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
      33             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      34             : # elif defined(__HP_aCC)
      35             : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
      36             : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
      37             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      38             : # else
      39             : #  define SWIGTEMPLATEDISAMBIGUATOR
      40             : # endif
      41             : #endif
      42             : 
      43             : /* inline attribute */
      44             : #ifndef SWIGINLINE
      45             : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
      46             : #   define SWIGINLINE inline
      47             : # else
      48             : #   define SWIGINLINE
      49             : # endif
      50             : #endif
      51             : 
      52             : /* attribute recognised by some compilers to avoid 'unused' warnings */
      53             : #ifndef SWIGUNUSED
      54             : # if defined(__GNUC__)
      55             : #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
      56             : #     define SWIGUNUSED __attribute__ ((__unused__))
      57             : #   else
      58             : #     define SWIGUNUSED
      59             : #   endif
      60             : # elif defined(__ICC)
      61             : #   define SWIGUNUSED __attribute__ ((__unused__))
      62             : # else
      63             : #   define SWIGUNUSED
      64             : # endif
      65             : #endif
      66             : 
      67             : #ifndef SWIG_MSC_UNSUPPRESS_4505
      68             : # if defined(_MSC_VER)
      69             : #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
      70             : # endif
      71             : #endif
      72             : 
      73             : #ifndef SWIGUNUSEDPARM
      74             : # ifdef __cplusplus
      75             : #   define SWIGUNUSEDPARM(p)
      76             : # else
      77             : #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
      78             : # endif
      79             : #endif
      80             : 
      81             : /* internal SWIG method */
      82             : #ifndef SWIGINTERN
      83             : # define SWIGINTERN static SWIGUNUSED
      84             : #endif
      85             : 
      86             : /* internal inline SWIG method */
      87             : #ifndef SWIGINTERNINLINE
      88             : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
      89             : #endif
      90             : 
      91             : /* exporting methods */
      92             : #if defined(__GNUC__)
      93             : #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
      94             : #    ifndef GCC_HASCLASSVISIBILITY
      95             : #      define GCC_HASCLASSVISIBILITY
      96             : #    endif
      97             : #  endif
      98             : #endif
      99             : 
     100             : #ifndef SWIGEXPORT
     101             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     102             : #   if defined(STATIC_LINKED)
     103             : #     define SWIGEXPORT
     104             : #   else
     105             : #     define SWIGEXPORT __declspec(dllexport)
     106             : #   endif
     107             : # else
     108             : #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
     109             : #     define SWIGEXPORT __attribute__ ((visibility("default")))
     110             : #   else
     111             : #     define SWIGEXPORT
     112             : #   endif
     113             : # endif
     114             : #endif
     115             : 
     116             : /* calling conventions for Windows */
     117             : #ifndef SWIGSTDCALL
     118             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     119             : #   define SWIGSTDCALL __stdcall
     120             : # else
     121             : #   define SWIGSTDCALL
     122             : # endif
     123             : #endif
     124             : 
     125             : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
     126             : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
     127             : # define _CRT_SECURE_NO_DEPRECATE
     128             : #endif
     129             : 
     130             : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
     131             : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
     132             : # define _SCL_SECURE_NO_DEPRECATE
     133             : #endif
     134             : 
     135             : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
     136             : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
     137             : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
     138             : #endif
     139             : 
     140             : /* Intel's compiler complains if a variable which was never initialised is
     141             :  * cast to void, which is a common idiom which we use to indicate that we
     142             :  * are aware a variable isn't used.  So we just silence that warning.
     143             :  * See: https://github.com/swig/swig/issues/192 for more discussion.
     144             :  */
     145             : #ifdef __INTEL_COMPILER
     146             : # pragma warning disable 592
     147             : #endif
     148             : 
     149             : 
     150             : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
     151             : /* Use debug wrappers with the Python release dll */
     152             : # undef _DEBUG
     153             : # include <Python.h>
     154             : # define _DEBUG
     155             : #else
     156             : # include <Python.h>
     157             : #endif
     158             : 
     159             : /* -----------------------------------------------------------------------------
     160             :  * swigrun.swg
     161             :  *
     162             :  * This file contains generic C API SWIG runtime support for pointer
     163             :  * type checking.
     164             :  * ----------------------------------------------------------------------------- */
     165             : 
     166             : /* This should only be incremented when either the layout of swig_type_info changes,
     167             :    or for whatever reason, the runtime changes incompatibly */
     168             : #define SWIG_RUNTIME_VERSION "4"
     169             : 
     170             : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
     171             : #ifdef SWIG_TYPE_TABLE
     172             : # define SWIG_QUOTE_STRING(x) #x
     173             : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
     174             : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
     175             : #else
     176             : # define SWIG_TYPE_TABLE_NAME
     177             : #endif
     178             : 
     179             : /*
     180             :   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
     181             :   creating a static or dynamic library from the SWIG runtime code.
     182             :   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
     183             : 
     184             :   But only do this if strictly necessary, ie, if you have problems
     185             :   with your compiler or suchlike.
     186             : */
     187             : 
     188             : #ifndef SWIGRUNTIME
     189             : # define SWIGRUNTIME SWIGINTERN
     190             : #endif
     191             : 
     192             : #ifndef SWIGRUNTIMEINLINE
     193             : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
     194             : #endif
     195             : 
     196             : /*  Generic buffer size */
     197             : #ifndef SWIG_BUFFER_SIZE
     198             : # define SWIG_BUFFER_SIZE 1024
     199             : #endif
     200             : 
     201             : /* Flags for pointer conversions */
     202             : #define SWIG_POINTER_DISOWN        0x1
     203             : #define SWIG_CAST_NEW_MEMORY       0x2
     204             : 
     205             : /* Flags for new pointer objects */
     206             : #define SWIG_POINTER_OWN           0x1
     207             : 
     208             : 
     209             : /*
     210             :    Flags/methods for returning states.
     211             : 
     212             :    The SWIG conversion methods, as ConvertPtr, return an integer
     213             :    that tells if the conversion was successful or not. And if not,
     214             :    an error code can be returned (see swigerrors.swg for the codes).
     215             : 
     216             :    Use the following macros/flags to set or process the returning
     217             :    states.
     218             : 
     219             :    In old versions of SWIG, code such as the following was usually written:
     220             : 
     221             :      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
     222             :        // success code
     223             :      } else {
     224             :        //fail code
     225             :      }
     226             : 
     227             :    Now you can be more explicit:
     228             : 
     229             :     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     230             :     if (SWIG_IsOK(res)) {
     231             :       // success code
     232             :     } else {
     233             :       // fail code
     234             :     }
     235             : 
     236             :    which is the same really, but now you can also do
     237             : 
     238             :     Type *ptr;
     239             :     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
     240             :     if (SWIG_IsOK(res)) {
     241             :       // success code
     242             :       if (SWIG_IsNewObj(res) {
     243             :         ...
     244             :   delete *ptr;
     245             :       } else {
     246             :         ...
     247             :       }
     248             :     } else {
     249             :       // fail code
     250             :     }
     251             : 
     252             :    I.e., now SWIG_ConvertPtr can return new objects and you can
     253             :    identify the case and take care of the deallocation. Of course that
     254             :    also requires SWIG_ConvertPtr to return new result values, such as
     255             : 
     256             :       int SWIG_ConvertPtr(obj, ptr,...) {
     257             :         if (<obj is ok>) {
     258             :           if (<need new object>) {
     259             :             *ptr = <ptr to new allocated object>;
     260             :             return SWIG_NEWOBJ;
     261             :           } else {
     262             :             *ptr = <ptr to old object>;
     263             :             return SWIG_OLDOBJ;
     264             :           }
     265             :         } else {
     266             :           return SWIG_BADOBJ;
     267             :         }
     268             :       }
     269             : 
     270             :    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
     271             :    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
     272             :    SWIG errors code.
     273             : 
     274             :    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
     275             :    allows to return the 'cast rank', for example, if you have this
     276             : 
     277             :        int food(double)
     278             :        int fooi(int);
     279             : 
     280             :    and you call
     281             : 
     282             :       food(1)   // cast rank '1'  (1 -> 1.0)
     283             :       fooi(1)   // cast rank '0'
     284             : 
     285             :    just use the SWIG_AddCast()/SWIG_CheckState()
     286             : */
     287             : 
     288             : #define SWIG_OK                    (0)
     289             : #define SWIG_ERROR                 (-1)
     290             : #define SWIG_IsOK(r)               (r >= 0)
     291             : #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
     292             : 
     293             : /* The CastRankLimit says how many bits are used for the cast rank */
     294             : #define SWIG_CASTRANKLIMIT         (1 << 8)
     295             : /* The NewMask denotes the object was created (using new/malloc) */
     296             : #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
     297             : /* The TmpMask is for in/out typemaps that use temporal objects */
     298             : #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
     299             : /* Simple returning values */
     300             : #define SWIG_BADOBJ                (SWIG_ERROR)
     301             : #define SWIG_OLDOBJ                (SWIG_OK)
     302             : #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
     303             : #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
     304             : /* Check, add and del mask methods */
     305             : #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
     306             : #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
     307             : #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
     308             : #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
     309             : #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
     310             : #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
     311             : 
     312             : /* Cast-Rank Mode */
     313             : #if defined(SWIG_CASTRANK_MODE)
     314             : #  ifndef SWIG_TypeRank
     315             : #    define SWIG_TypeRank             unsigned long
     316             : #  endif
     317             : #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
     318             : #    define SWIG_MAXCASTRANK          (2)
     319             : #  endif
     320             : #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
     321             : #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
     322             : SWIGINTERNINLINE int SWIG_AddCast(int r) {
     323             :   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
     324             : }
     325             : SWIGINTERNINLINE int SWIG_CheckState(int r) {
     326             :   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
     327             : }
     328             : #else /* no cast-rank mode */
     329             : #  define SWIG_AddCast(r) (r)
     330             : #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
     331             : #endif
     332             : 
     333             : 
     334             : #include <string.h>
     335             : 
     336             : #ifdef __cplusplus
     337             : extern "C" {
     338             : #endif
     339             : 
     340             : typedef void *(*swig_converter_func)(void *, int *);
     341             : typedef struct swig_type_info *(*swig_dycast_func)(void **);
     342             : 
     343             : /* Structure to store information on one type */
     344             : typedef struct swig_type_info {
     345             :   const char             *name;     /* mangled name of this type */
     346             :   const char             *str;      /* human readable name of this type */
     347             :   swig_dycast_func        dcast;    /* dynamic cast function down a hierarchy */
     348             :   struct swig_cast_info  *cast;     /* linked list of types that can cast into this type */
     349             :   void                   *clientdata;   /* language specific type data */
     350             :   int                    owndata;   /* flag if the structure owns the clientdata */
     351             : } swig_type_info;
     352             : 
     353             : /* Structure to store a type and conversion function used for casting */
     354             : typedef struct swig_cast_info {
     355             :   swig_type_info         *type;     /* pointer to type that is equivalent to this type */
     356             :   swig_converter_func     converter;    /* function to cast the void pointers */
     357             :   struct swig_cast_info  *next;     /* pointer to next cast in linked list */
     358             :   struct swig_cast_info  *prev;     /* pointer to the previous cast */
     359             : } swig_cast_info;
     360             : 
     361             : /* Structure used to store module information
     362             :  * Each module generates one structure like this, and the runtime collects
     363             :  * all of these structures and stores them in a circularly linked list.*/
     364             : typedef struct swig_module_info {
     365             :   swig_type_info         **types;   /* Array of pointers to swig_type_info structures that are in this module */
     366             :   size_t                 size;            /* Number of types in this module */
     367             :   struct swig_module_info *next;    /* Pointer to next element in circularly linked list */
     368             :   swig_type_info         **type_initial;  /* Array of initially generated type structures */
     369             :   swig_cast_info         **cast_initial;  /* Array of initially generated casting structures */
     370             :   void                    *clientdata;    /* Language specific module data */
     371             : } swig_module_info;
     372             : 
     373             : /*
     374             :   Compare two type names skipping the space characters, therefore
     375             :   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
     376             : 
     377             :   Return 0 when the two name types are equivalent, as in
     378             :   strncmp, but skipping ' '.
     379             : */
     380             : SWIGRUNTIME int
     381           0 : SWIG_TypeNameComp(const char *f1, const char *l1,
     382             :       const char *f2, const char *l2) {
     383           0 :   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
     384           0 :     while ((*f1 == ' ') && (f1 != l1)) ++f1;
     385           0 :     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     386           0 :     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
     387             :   }
     388           0 :   return (int)((l1 - f1) - (l2 - f2));
     389             : }
     390             : 
     391             : /*
     392             :   Check type equivalence in a name list like <name1>|<name2>|...
     393             :   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
     394             : */
     395             : SWIGRUNTIME int
     396           0 : SWIG_TypeCmp(const char *nb, const char *tb) {
     397             :   int equiv = 1;
     398           0 :   const char* te = tb + strlen(tb);
     399             :   const char* ne = nb;
     400           0 :   while (equiv != 0 && *ne) {
     401           0 :     for (nb = ne; *ne; ++ne) {
     402           0 :       if (*ne == '|') break;
     403             :     }
     404           0 :     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
     405           0 :     if (*ne) ++ne;
     406             :   }
     407           0 :   return equiv;
     408             : }
     409             : 
     410             : /*
     411             :   Check type equivalence in a name list like <name1>|<name2>|...
     412             :   Return 0 if not equal, 1 if equal
     413             : */
     414             : SWIGRUNTIME int
     415             : SWIG_TypeEquiv(const char *nb, const char *tb) {
     416           0 :   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
     417             : }
     418             : 
     419             : /*
     420             :   Check the typename
     421             : */
     422             : SWIGRUNTIME swig_cast_info *
     423           0 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
     424           0 :   if (ty) {
     425           0 :     swig_cast_info *iter = ty->cast;
     426           0 :     while (iter) {
     427           0 :       if (strcmp(iter->type->name, c) == 0) {
     428           0 :         if (iter == ty->cast)
     429             :           return iter;
     430             :         /* Move iter to the top of the linked list */
     431           0 :         iter->prev->next = iter->next;
     432           0 :         if (iter->next)
     433           0 :           iter->next->prev = iter->prev;
     434           0 :         iter->next = ty->cast;
     435           0 :         iter->prev = 0;
     436           0 :         if (ty->cast) ty->cast->prev = iter;
     437           0 :         ty->cast = iter;
     438           0 :         return iter;
     439             :       }
     440           0 :       iter = iter->next;
     441             :     }
     442             :   }
     443             :   return 0;
     444             : }
     445             : 
     446             : /*
     447             :   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
     448             : */
     449             : SWIGRUNTIME swig_cast_info *
     450             : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
     451             :   if (ty) {
     452             :     swig_cast_info *iter = ty->cast;
     453             :     while (iter) {
     454             :       if (iter->type == from) {
     455             :         if (iter == ty->cast)
     456             :           return iter;
     457             :         /* Move iter to the top of the linked list */
     458             :         iter->prev->next = iter->next;
     459             :         if (iter->next)
     460             :           iter->next->prev = iter->prev;
     461             :         iter->next = ty->cast;
     462             :         iter->prev = 0;
     463             :         if (ty->cast) ty->cast->prev = iter;
     464             :         ty->cast = iter;
     465             :         return iter;
     466             :       }
     467             :       iter = iter->next;
     468             :     }
     469             :   }
     470             :   return 0;
     471             : }
     472             : 
     473             : /*
     474             :   Cast a pointer up an inheritance hierarchy
     475             : */
     476             : SWIGRUNTIMEINLINE void *
     477             : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
     478           0 :   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
     479             : }
     480             : 
     481             : /*
     482             :    Dynamic pointer casting. Down an inheritance hierarchy
     483             : */
     484             : SWIGRUNTIME swig_type_info *
     485             : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
     486             :   swig_type_info *lastty = ty;
     487             :   if (!ty || !ty->dcast) return ty;
     488             :   while (ty && (ty->dcast)) {
     489             :     ty = (*ty->dcast)(ptr);
     490             :     if (ty) lastty = ty;
     491             :   }
     492             :   return lastty;
     493             : }
     494             : 
     495             : /*
     496             :   Return the name associated with this type
     497             : */
     498             : SWIGRUNTIMEINLINE const char *
     499             : SWIG_TypeName(const swig_type_info *ty) {
     500             :   return ty->name;
     501             : }
     502             : 
     503             : /*
     504             :   Return the pretty name associated with this type,
     505             :   that is an unmangled type name in a form presentable to the user.
     506             : */
     507             : SWIGRUNTIME const char *
     508             : SWIG_TypePrettyName(const swig_type_info *type) {
     509             :   /* The "str" field contains the equivalent pretty names of the
     510             :      type, separated by vertical-bar characters.  We choose
     511             :      to print the last name, as it is often (?) the most
     512             :      specific. */
     513           1 :   if (!type) return NULL;
     514           1 :   if (type->str != NULL) {
     515             :     const char *last_name = type->str;
     516             :     const char *s;
     517           1 :     for (s = type->str; *s; s++)
     518           1 :       if (*s == '|') last_name = s+1;
     519             :     return last_name;
     520             :   }
     521             :   else
     522           0 :     return type->name;
     523             : }
     524             : 
     525             : /*
     526             :    Set the clientdata field for a type
     527             : */
     528             : SWIGRUNTIME void
     529           1 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
     530           1 :   swig_cast_info *cast = ti->cast;
     531             :   /* if (ti->clientdata == clientdata) return; */
     532           1 :   ti->clientdata = clientdata;
     533             : 
     534           1 :   while (cast) {
     535           1 :     if (!cast->converter) {
     536           1 :       swig_type_info *tc = cast->type;
     537           1 :       if (!tc->clientdata) {
     538           0 :   SWIG_TypeClientData(tc, clientdata);
     539             :       }
     540             :     }
     541           1 :     cast = cast->next;
     542             :   }
     543           1 : }
     544             : SWIGRUNTIME void
     545             : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
     546           1 :   SWIG_TypeClientData(ti, clientdata);
     547           1 :   ti->owndata = 1;
     548             : }
     549             : 
     550             : /*
     551             :   Search for a swig_type_info structure only by mangled name
     552             :   Search is a O(log #types)
     553             : 
     554             :   We start searching at module start, and finish searching when start == end.
     555             :   Note: if start == end at the beginning of the function, we go all the way around
     556             :   the circular list.
     557             : */
     558             : SWIGRUNTIME swig_type_info *
     559           1 : SWIG_MangledTypeQueryModule(swig_module_info *start,
     560             :                             swig_module_info *end,
     561             :                 const char *name) {
     562             :   swig_module_info *iter = start;
     563             :   do {
     564           1 :     if (iter->size) {
     565             :       size_t l = 0;
     566           1 :       size_t r = iter->size - 1;
     567             :       do {
     568             :   /* since l+r >= 0, we can (>> 1) instead (/ 2) */
     569           1 :   size_t i = (l + r) >> 1;
     570           1 :   const char *iname = iter->types[i]->name;
     571           1 :   if (iname) {
     572           1 :     int compare = strcmp(name, iname);
     573           1 :     if (compare == 0) {
     574             :       return iter->types[i];
     575           1 :     } else if (compare < 0) {
     576           1 :       if (i) {
     577           1 :         r = i - 1;
     578             :       } else {
     579             :         break;
     580             :       }
     581             :     } else if (compare > 0) {
     582           1 :       l = i + 1;
     583             :     }
     584             :   } else {
     585             :     break; /* should never happen */
     586             :   }
     587           1 :       } while (l <= r);
     588             :     }
     589           0 :     iter = iter->next;
     590           0 :   } while (iter != end);
     591             :   return 0;
     592             : }
     593             : 
     594             : /*
     595             :   Search for a swig_type_info structure for either a mangled name or a human readable name.
     596             :   It first searches the mangled names of the types, which is a O(log #types)
     597             :   If a type is not found it then searches the human readable names, which is O(#types).
     598             : 
     599             :   We start searching at module start, and finish searching when start == end.
     600             :   Note: if start == end at the beginning of the function, we go all the way around
     601             :   the circular list.
     602             : */
     603             : SWIGRUNTIME swig_type_info *
     604           1 : SWIG_TypeQueryModule(swig_module_info *start,
     605             :                      swig_module_info *end,
     606             :          const char *name) {
     607             :   /* STEP 1: Search the name field using binary search */
     608           1 :   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
     609           1 :   if (ret) {
     610             :     return ret;
     611             :   } else {
     612             :     /* STEP 2: If the type hasn't been found, do a complete search
     613             :        of the str field (the human readable name) */
     614             :     swig_module_info *iter = start;
     615             :     do {
     616             :       size_t i = 0;
     617           0 :       for (; i < iter->size; ++i) {
     618           0 :   if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
     619             :     return iter->types[i];
     620             :       }
     621           0 :       iter = iter->next;
     622           0 :     } while (iter != end);
     623             :   }
     624             : 
     625             :   /* neither found a match */
     626             :   return 0;
     627             : }
     628             : 
     629             : /*
     630             :    Pack binary data into a string
     631             : */
     632             : SWIGRUNTIME char *
     633             : SWIG_PackData(char *c, void *ptr, size_t sz) {
     634             :   static const char hex[17] = "0123456789abcdef";
     635             :   const unsigned char *u = (unsigned char *) ptr;
     636           0 :   const unsigned char *eu =  u + sz;
     637           0 :   for (; u != eu; ++u) {
     638           0 :     unsigned char uu = *u;
     639           0 :     *(c++) = hex[(uu & 0xf0) >> 4];
     640           0 :     *(c++) = hex[uu & 0xf];
     641             :   }
     642             :   return c;
     643             : }
     644             : 
     645             : /*
     646             :    Unpack binary data from a string
     647             : */
     648             : SWIGRUNTIME const char *
     649             : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
     650             :   unsigned char *u = (unsigned char *) ptr;
     651             :   const unsigned char *eu = u + sz;
     652             :   for (; u != eu; ++u) {
     653             :     char d = *(c++);
     654             :     unsigned char uu;
     655             :     if ((d >= '0') && (d <= '9'))
     656             :       uu = (unsigned char)((d - '0') << 4);
     657             :     else if ((d >= 'a') && (d <= 'f'))
     658             :       uu = (unsigned char)((d - ('a'-10)) << 4);
     659             :     else
     660             :       return (char *) 0;
     661             :     d = *(c++);
     662             :     if ((d >= '0') && (d <= '9'))
     663             :       uu |= (unsigned char)(d - '0');
     664             :     else if ((d >= 'a') && (d <= 'f'))
     665             :       uu |= (unsigned char)(d - ('a'-10));
     666             :     else
     667             :       return (char *) 0;
     668             :     *u = uu;
     669             :   }
     670             :   return c;
     671             : }
     672             : 
     673             : /*
     674             :    Pack 'void *' into a string buffer.
     675             : */
     676             : SWIGRUNTIME char *
     677           0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
     678             :   char *r = buff;
     679           0 :   if ((2*sizeof(void *) + 2) > bsz) return 0;
     680           0 :   *(r++) = '_';
     681             :   r = SWIG_PackData(r,&ptr,sizeof(void *));
     682           0 :   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
     683             :   strcpy(r,name);
     684           0 :   return buff;
     685             : }
     686             : 
     687             : SWIGRUNTIME const char *
     688             : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
     689             :   if (*c != '_') {
     690             :     if (strcmp(c,"NULL") == 0) {
     691             :       *ptr = (void *) 0;
     692             :       return name;
     693             :     } else {
     694             :       return 0;
     695             :     }
     696             :   }
     697             :   return SWIG_UnpackData(++c,ptr,sizeof(void *));
     698             : }
     699             : 
     700             : SWIGRUNTIME char *
     701           0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
     702             :   char *r = buff;
     703           0 :   size_t lname = (name ? strlen(name) : 0);
     704           0 :   if ((2*sz + 2 + lname) > bsz) return 0;
     705           0 :   *(r++) = '_';
     706             :   r = SWIG_PackData(r,ptr,sz);
     707           0 :   if (lname) {
     708           0 :     strncpy(r,name,lname+1);
     709             :   } else {
     710           0 :     *r = 0;
     711             :   }
     712             :   return buff;
     713             : }
     714             : 
     715             : SWIGRUNTIME const char *
     716             : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
     717             :   if (*c != '_') {
     718             :     if (strcmp(c,"NULL") == 0) {
     719             :       memset(ptr,0,sz);
     720             :       return name;
     721             :     } else {
     722             :       return 0;
     723             :     }
     724             :   }
     725             :   return SWIG_UnpackData(++c,ptr,sz);
     726             : }
     727             : 
     728             : #ifdef __cplusplus
     729             : }
     730             : #endif
     731             : 
     732             : /*  Errors in SWIG */
     733             : #define  SWIG_UnknownError         -1
     734             : #define  SWIG_IOError            -2
     735             : #define  SWIG_RuntimeError       -3
     736             : #define  SWIG_IndexError         -4
     737             : #define  SWIG_TypeError          -5
     738             : #define  SWIG_DivisionByZero     -6
     739             : #define  SWIG_OverflowError      -7
     740             : #define  SWIG_SyntaxError        -8
     741             : #define  SWIG_ValueError         -9
     742             : #define  SWIG_SystemError        -10
     743             : #define  SWIG_AttributeError     -11
     744             : #define  SWIG_MemoryError        -12
     745             : #define  SWIG_NullReferenceError   -13
     746             : 
     747             : 
     748             : 
     749             : /* Compatibility macros for Python 3 */
     750             : #if PY_VERSION_HEX >= 0x03000000
     751             : 
     752             : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
     753             : #define PyInt_Check(x) PyLong_Check(x)
     754             : #define PyInt_AsLong(x) PyLong_AsLong(x)
     755             : #define PyInt_FromLong(x) PyLong_FromLong(x)
     756             : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
     757             : #define PyString_Check(name) PyBytes_Check(name)
     758             : #define PyString_FromString(x) PyUnicode_FromString(x)
     759             : #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
     760             : #define PyString_AsString(str) PyBytes_AsString(str)
     761             : #define PyString_Size(str) PyBytes_Size(str)  
     762             : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
     763             : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
     764             : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
     765             : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
     766             : 
     767             : #endif
     768             : 
     769             : #ifndef Py_TYPE
     770             : #  define Py_TYPE(op) ((op)->ob_type)
     771             : #endif
     772             : 
     773             : /* SWIG APIs for compatibility of both Python 2 & 3 */
     774             : 
     775             : #if PY_VERSION_HEX >= 0x03000000
     776             : #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
     777             : #else
     778             : #  define SWIG_Python_str_FromFormat PyString_FromFormat
     779             : #endif
     780             : 
     781             : 
     782             : /* Warning: This function will allocate a new string in Python 3,
     783             :  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
     784             :  */
     785             : SWIGINTERN char*
     786             : SWIG_Python_str_AsChar(PyObject *str)
     787             : {
     788             : #if PY_VERSION_HEX >= 0x03000000
     789             :   char *cstr;
     790             :   char *newstr;
     791             :   Py_ssize_t len;
     792             :   str = PyUnicode_AsUTF8String(str);
     793             :   PyBytes_AsStringAndSize(str, &cstr, &len);
     794             :   newstr = (char *) malloc(len+1);
     795             :   memcpy(newstr, cstr, len+1);
     796             :   Py_XDECREF(str);
     797             :   return newstr;
     798             : #else
     799             :   return PyString_AsString(str);
     800             : #endif
     801             : }
     802             : 
     803             : #if PY_VERSION_HEX >= 0x03000000
     804             : #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
     805             : #else
     806             : #  define SWIG_Python_str_DelForPy3(x) 
     807             : #endif
     808             : 
     809             : 
     810             : SWIGINTERN PyObject*
     811             : SWIG_Python_str_FromChar(const char *c)
     812             : {
     813             : #if PY_VERSION_HEX >= 0x03000000
     814           1 :   return PyUnicode_FromString(c); 
     815             : #else
     816             :   return PyString_FromString(c);
     817             : #endif
     818             : }
     819             : 
     820             : /* Add PyOS_snprintf for old Pythons */
     821             : #if PY_VERSION_HEX < 0x02020000
     822             : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
     823             : #  define PyOS_snprintf _snprintf
     824             : # else
     825             : #  define PyOS_snprintf snprintf
     826             : # endif
     827             : #endif
     828             : 
     829             : /* A crude PyString_FromFormat implementation for old Pythons */
     830             : #if PY_VERSION_HEX < 0x02020000
     831             : 
     832             : #ifndef SWIG_PYBUFFER_SIZE
     833             : # define SWIG_PYBUFFER_SIZE 1024
     834             : #endif
     835             : 
     836             : static PyObject *
     837             : PyString_FromFormat(const char *fmt, ...) {
     838             :   va_list ap;
     839             :   char buf[SWIG_PYBUFFER_SIZE * 2];
     840             :   int res;
     841             :   va_start(ap, fmt);
     842             :   res = vsnprintf(buf, sizeof(buf), fmt, ap);
     843             :   va_end(ap);
     844             :   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
     845             : }
     846             : #endif
     847             : 
     848             : #ifndef PyObject_DEL
     849             : # define PyObject_DEL PyObject_Del
     850             : #endif
     851             : 
     852             : /* A crude PyExc_StopIteration exception for old Pythons */
     853             : #if PY_VERSION_HEX < 0x02020000
     854             : # ifndef PyExc_StopIteration
     855             : #  define PyExc_StopIteration PyExc_RuntimeError
     856             : # endif
     857             : # ifndef PyObject_GenericGetAttr
     858             : #  define PyObject_GenericGetAttr 0
     859             : # endif
     860             : #endif
     861             : 
     862             : /* Py_NotImplemented is defined in 2.1 and up. */
     863             : #if PY_VERSION_HEX < 0x02010000
     864             : # ifndef Py_NotImplemented
     865             : #  define Py_NotImplemented PyExc_RuntimeError
     866             : # endif
     867             : #endif
     868             : 
     869             : /* A crude PyString_AsStringAndSize implementation for old Pythons */
     870             : #if PY_VERSION_HEX < 0x02010000
     871             : # ifndef PyString_AsStringAndSize
     872             : #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
     873             : # endif
     874             : #endif
     875             : 
     876             : /* PySequence_Size for old Pythons */
     877             : #if PY_VERSION_HEX < 0x02000000
     878             : # ifndef PySequence_Size
     879             : #  define PySequence_Size PySequence_Length
     880             : # endif
     881             : #endif
     882             : 
     883             : /* PyBool_FromLong for old Pythons */
     884             : #if PY_VERSION_HEX < 0x02030000
     885             : static
     886             : PyObject *PyBool_FromLong(long ok)
     887             : {
     888             :   PyObject *result = ok ? Py_True : Py_False;
     889             :   Py_INCREF(result);
     890             :   return result;
     891             : }
     892             : #endif
     893             : 
     894             : /* Py_ssize_t for old Pythons */
     895             : /* This code is as recommended by: */
     896             : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
     897             : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
     898             : typedef int Py_ssize_t;
     899             : # define PY_SSIZE_T_MAX INT_MAX
     900             : # define PY_SSIZE_T_MIN INT_MIN
     901             : typedef inquiry lenfunc;
     902             : typedef intargfunc ssizeargfunc;
     903             : typedef intintargfunc ssizessizeargfunc;
     904             : typedef intobjargproc ssizeobjargproc;
     905             : typedef intintobjargproc ssizessizeobjargproc;
     906             : typedef getreadbufferproc readbufferproc;
     907             : typedef getwritebufferproc writebufferproc;
     908             : typedef getsegcountproc segcountproc;
     909             : typedef getcharbufferproc charbufferproc;
     910             : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
     911             : {
     912             :   long result = 0;
     913             :   PyObject *i = PyNumber_Int(x);
     914             :   if (i) {
     915             :     result = PyInt_AsLong(i);
     916             :     Py_DECREF(i);
     917             :   }
     918             :   return result;
     919             : }
     920             : #endif
     921             : 
     922             : #if PY_VERSION_HEX < 0x02050000
     923             : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
     924             : #endif
     925             : 
     926             : #if PY_VERSION_HEX < 0x02040000
     927             : #define Py_VISIT(op)        \
     928             :   do {            \
     929             :     if (op) {         \
     930             :       int vret = visit((op), arg);    \
     931             :       if (vret)         \
     932             :         return vret;        \
     933             :     }           \
     934             :   } while (0)
     935             : #endif
     936             : 
     937             : #if PY_VERSION_HEX < 0x02030000
     938             : typedef struct {
     939             :   PyTypeObject type;
     940             :   PyNumberMethods as_number;
     941             :   PyMappingMethods as_mapping;
     942             :   PySequenceMethods as_sequence;
     943             :   PyBufferProcs as_buffer;
     944             :   PyObject *name, *slots;
     945             : } PyHeapTypeObject;
     946             : #endif
     947             : 
     948             : #if PY_VERSION_HEX < 0x02030000
     949             : typedef destructor freefunc;
     950             : #endif
     951             : 
     952             : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     953             :      (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     954             :      (PY_MAJOR_VERSION > 3))
     955             : # define SWIGPY_USE_CAPSULE
     956             : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
     957             : #endif
     958             : 
     959             : #if PY_VERSION_HEX < 0x03020000
     960             : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
     961             : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
     962             : #define Py_hash_t long
     963             : #endif
     964             : 
     965             : /* -----------------------------------------------------------------------------
     966             :  * error manipulation
     967             :  * ----------------------------------------------------------------------------- */
     968             : 
     969             : SWIGRUNTIME PyObject*
     970           0 : SWIG_Python_ErrorType(int code) {
     971             :   PyObject* type = 0;
     972           0 :   switch(code) {
     973           0 :   case SWIG_MemoryError:
     974           0 :     type = PyExc_MemoryError;
     975           0 :     break;
     976           0 :   case SWIG_IOError:
     977           0 :     type = PyExc_IOError;
     978           0 :     break;
     979           0 :   case SWIG_RuntimeError:
     980           0 :     type = PyExc_RuntimeError;
     981           0 :     break;
     982           0 :   case SWIG_IndexError:
     983           0 :     type = PyExc_IndexError;
     984           0 :     break;
     985           0 :   case SWIG_TypeError:
     986           0 :     type = PyExc_TypeError;
     987           0 :     break;
     988           0 :   case SWIG_DivisionByZero:
     989           0 :     type = PyExc_ZeroDivisionError;
     990           0 :     break;
     991           0 :   case SWIG_OverflowError:
     992           0 :     type = PyExc_OverflowError;
     993           0 :     break;
     994           0 :   case SWIG_SyntaxError:
     995           0 :     type = PyExc_SyntaxError;
     996           0 :     break;
     997           0 :   case SWIG_ValueError:
     998           0 :     type = PyExc_ValueError;
     999           0 :     break;
    1000           0 :   case SWIG_SystemError:
    1001           0 :     type = PyExc_SystemError;
    1002           0 :     break;
    1003           0 :   case SWIG_AttributeError:
    1004           0 :     type = PyExc_AttributeError;
    1005           0 :     break;
    1006           0 :   default:
    1007           0 :     type = PyExc_RuntimeError;
    1008             :   }
    1009           0 :   return type;
    1010             : }
    1011             : 
    1012             : 
    1013             : SWIGRUNTIME void
    1014             : SWIG_Python_AddErrorMsg(const char* mesg)
    1015             : {
    1016             :   PyObject *type = 0;
    1017             :   PyObject *value = 0;
    1018             :   PyObject *traceback = 0;
    1019             : 
    1020             :   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
    1021             :   if (value) {
    1022             :     char *tmp;
    1023             :     PyObject *old_str = PyObject_Str(value);
    1024             :     PyErr_Clear();
    1025             :     Py_XINCREF(type);
    1026             : 
    1027             :     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    1028             :     SWIG_Python_str_DelForPy3(tmp);
    1029             :     Py_DECREF(old_str);
    1030             :     Py_DECREF(value);
    1031             :   } else {
    1032             :     PyErr_SetString(PyExc_RuntimeError, mesg);
    1033             :   }
    1034             : }
    1035             : 
    1036             : #if defined(SWIG_PYTHON_NO_THREADS)
    1037             : #  if defined(SWIG_PYTHON_THREADS)
    1038             : #    undef SWIG_PYTHON_THREADS
    1039             : #  endif
    1040             : #endif
    1041             : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
    1042             : #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
    1043             : #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
    1044             : #      define SWIG_PYTHON_USE_GIL
    1045             : #    endif
    1046             : #  endif
    1047             : #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
    1048             : #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
    1049             : #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
    1050             : #    endif
    1051             : #    ifdef __cplusplus /* C++ code */
    1052             :        class SWIG_Python_Thread_Block {
    1053             :          bool status;
    1054             :          PyGILState_STATE state;
    1055             :        public:
    1056             :          void end() { if (status) { PyGILState_Release(state); status = false;} }
    1057             :          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
    1058             :          ~SWIG_Python_Thread_Block() { end(); }
    1059             :        };
    1060             :        class SWIG_Python_Thread_Allow {
    1061             :          bool status;
    1062             :          PyThreadState *save;
    1063             :        public:
    1064             :          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
    1065             :          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
    1066             :          ~SWIG_Python_Thread_Allow() { end(); }
    1067             :        };
    1068             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
    1069             : #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
    1070             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
    1071             : #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
    1072             : #    else /* C code */
    1073             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
    1074             : #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
    1075             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
    1076             : #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
    1077             : #    endif
    1078             : #  else /* Old thread way, not implemented, user must provide it */
    1079             : #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
    1080             : #      define SWIG_PYTHON_INITIALIZE_THREADS
    1081             : #    endif
    1082             : #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
    1083             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
    1084             : #    endif
    1085             : #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
    1086             : #      define SWIG_PYTHON_THREAD_END_BLOCK
    1087             : #    endif
    1088             : #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
    1089             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
    1090             : #    endif
    1091             : #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
    1092             : #      define SWIG_PYTHON_THREAD_END_ALLOW
    1093             : #    endif
    1094             : #  endif
    1095             : #else /* No thread support */
    1096             : #  define SWIG_PYTHON_INITIALIZE_THREADS
    1097             : #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
    1098             : #  define SWIG_PYTHON_THREAD_END_BLOCK
    1099             : #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
    1100             : #  define SWIG_PYTHON_THREAD_END_ALLOW
    1101             : #endif
    1102             : 
    1103             : /* -----------------------------------------------------------------------------
    1104             :  * Python API portion that goes into the runtime
    1105             :  * ----------------------------------------------------------------------------- */
    1106             : 
    1107             : #ifdef __cplusplus
    1108             : extern "C" {
    1109             : #endif
    1110             : 
    1111             : /* -----------------------------------------------------------------------------
    1112             :  * Constant declarations
    1113             :  * ----------------------------------------------------------------------------- */
    1114             : 
    1115             : /* Constant Types */
    1116             : #define SWIG_PY_POINTER 4
    1117             : #define SWIG_PY_BINARY  5
    1118             : 
    1119             : /* Constant information structure */
    1120             : typedef struct swig_const_info {
    1121             :   int type;
    1122             :   char *name;
    1123             :   long lvalue;
    1124             :   double dvalue;
    1125             :   void   *pvalue;
    1126             :   swig_type_info **ptype;
    1127             : } swig_const_info;
    1128             : 
    1129             : 
    1130             : /* -----------------------------------------------------------------------------
    1131             :  * Wrapper of PyInstanceMethod_New() used in Python 3
    1132             :  * It is exported to the generated module, used for -fastproxy
    1133             :  * ----------------------------------------------------------------------------- */
    1134             : #if PY_VERSION_HEX >= 0x03000000
    1135           0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
    1136             : {
    1137           0 :   return PyInstanceMethod_New(func);
    1138             : }
    1139             : #else
    1140             : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
    1141             : {
    1142             :   return NULL;
    1143             : }
    1144             : #endif
    1145             : 
    1146             : #ifdef __cplusplus
    1147             : }
    1148             : #endif
    1149             : 
    1150             : 
    1151             : /* -----------------------------------------------------------------------------
    1152             :  * pyrun.swg
    1153             :  *
    1154             :  * This file contains the runtime support for Python modules
    1155             :  * and includes code for managing global variables and pointer
    1156             :  * type checking.
    1157             :  *
    1158             :  * ----------------------------------------------------------------------------- */
    1159             : 
    1160             : /* Common SWIG API */
    1161             : 
    1162             : /* for raw pointers */
    1163             : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
    1164             : #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
    1165             : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
    1166             : 
    1167             : #ifdef SWIGPYTHON_BUILTIN
    1168             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
    1169             : #else
    1170             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
    1171             : #endif
    1172             : 
    1173             : #define SWIG_InternalNewPointerObj(ptr, type, flags)  SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
    1174             : 
    1175             : #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
    1176             : #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
    1177             : #define swig_owntype                                    int
    1178             : 
    1179             : /* for raw packed data */
    1180             : #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
    1181             : #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
    1182             : 
    1183             : /* for class or struct pointers */
    1184             : #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
    1185             : #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
    1186             : 
    1187             : /* for C or C++ function pointers */
    1188             : #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
    1189             : #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
    1190             : 
    1191             : /* for C++ member pointers, ie, member methods */
    1192             : #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
    1193             : #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
    1194             : 
    1195             : 
    1196             : /* Runtime API */
    1197             : 
    1198             : #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
    1199             : #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
    1200             : #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
    1201             : 
    1202             : #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
    1203             : #define SWIG_SetErrorMsg                          SWIG_Python_SetErrorMsg          
    1204             : #define SWIG_ErrorType(code)                      SWIG_Python_ErrorType(code)                        
    1205             : #define SWIG_Error(code, msg)               SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
    1206             : #define SWIG_fail                           goto fail            
    1207             : 
    1208             : 
    1209             : /* Runtime API implementation */
    1210             : 
    1211             : /* Error manipulation */
    1212             : 
    1213             : SWIGINTERN void 
    1214             : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
    1215             :   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
    1216             :   PyErr_SetObject(errtype, obj);
    1217             :   Py_DECREF(obj);
    1218             :   SWIG_PYTHON_THREAD_END_BLOCK;
    1219             : }
    1220             : 
    1221             : SWIGINTERN void 
    1222             : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
    1223             :   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    1224           0 :   PyErr_SetString(errtype, msg);
    1225             :   SWIG_PYTHON_THREAD_END_BLOCK;
    1226             : }
    1227             : 
    1228             : #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
    1229             : 
    1230             : /* Set a constant value */
    1231             : 
    1232             : #if defined(SWIGPYTHON_BUILTIN)
    1233             : 
    1234             : SWIGINTERN void
    1235             : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
    1236             :   PyObject *s = PyString_InternFromString(key);
    1237             :   PyList_Append(seq, s);
    1238             :   Py_DECREF(s);
    1239             : }
    1240             : 
    1241             : SWIGINTERN void
    1242             : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
    1243             : #if PY_VERSION_HEX < 0x02030000
    1244             :   PyDict_SetItemString(d, (char *)name, obj);
    1245             : #else
    1246             :   PyDict_SetItemString(d, name, obj);
    1247             : #endif
    1248             :   Py_DECREF(obj);
    1249             :   if (public_interface)
    1250             :     SwigPyBuiltin_AddPublicSymbol(public_interface, name);
    1251             : }
    1252             : 
    1253             : #else
    1254             : 
    1255             : SWIGINTERN void
    1256           1 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
    1257             : #if PY_VERSION_HEX < 0x02030000
    1258             :   PyDict_SetItemString(d, (char *)name, obj);
    1259             : #else
    1260           1 :   PyDict_SetItemString(d, name, obj);
    1261             : #endif
    1262           1 :   Py_DECREF(obj);                            
    1263           1 : }
    1264             : 
    1265             : #endif
    1266             : 
    1267             : /* Append a value to the result obj */
    1268             : 
    1269             : SWIGINTERN PyObject*
    1270           1 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
    1271             : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
    1272           1 :   if (!result) {
    1273             :     result = obj;
    1274           1 :   } else if (result == Py_None) {
    1275           1 :     Py_DECREF(result);
    1276             :     result = obj;
    1277             :   } else {
    1278           0 :     if (!PyList_Check(result)) {
    1279             :       PyObject *o2 = result;
    1280           0 :       result = PyList_New(1);
    1281           0 :       PyList_SetItem(result, 0, o2);
    1282             :     }
    1283           0 :     PyList_Append(result,obj);
    1284           0 :     Py_DECREF(obj);
    1285             :   }
    1286           1 :   return result;
    1287             : #else
    1288             :   PyObject*   o2;
    1289             :   PyObject*   o3;
    1290             :   if (!result) {
    1291             :     result = obj;
    1292             :   } else if (result == Py_None) {
    1293             :     Py_DECREF(result);
    1294             :     result = obj;
    1295             :   } else {
    1296             :     if (!PyTuple_Check(result)) {
    1297             :       o2 = result;
    1298             :       result = PyTuple_New(1);
    1299             :       PyTuple_SET_ITEM(result, 0, o2);
    1300             :     }
    1301             :     o3 = PyTuple_New(1);
    1302             :     PyTuple_SET_ITEM(o3, 0, obj);
    1303             :     o2 = result;
    1304             :     result = PySequence_Concat(o2, o3);
    1305             :     Py_DECREF(o2);
    1306             :     Py_DECREF(o3);
    1307             :   }
    1308             :   return result;
    1309             : #endif
    1310             : }
    1311             : 
    1312             : /* Unpack the argument tuple */
    1313             : 
    1314             : SWIGINTERN Py_ssize_t
    1315             : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
    1316             : {
    1317             :   if (!args) {
    1318             :     if (!min && !max) {
    1319             :       return 1;
    1320             :     } else {
    1321             :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
    1322             :        name, (min == max ? "" : "at least "), (int)min);
    1323             :       return 0;
    1324             :     }
    1325             :   }  
    1326             :   if (!PyTuple_Check(args)) {
    1327             :     if (min <= 1 && max >= 1) {
    1328             :       Py_ssize_t i;
    1329             :       objs[0] = args;
    1330             :       for (i = 1; i < max; ++i) {
    1331             :   objs[i] = 0;
    1332             :       }
    1333             :       return 2;
    1334             :     }
    1335             :     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    1336             :     return 0;
    1337             :   } else {
    1338             :     Py_ssize_t l = PyTuple_GET_SIZE(args);
    1339             :     if (l < min) {
    1340             :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
    1341             :        name, (min == max ? "" : "at least "), (int)min, (int)l);
    1342             :       return 0;
    1343             :     } else if (l > max) {
    1344             :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
    1345             :        name, (min == max ? "" : "at most "), (int)max, (int)l);
    1346             :       return 0;
    1347             :     } else {
    1348             :       Py_ssize_t i;
    1349             :       for (i = 0; i < l; ++i) {
    1350             :   objs[i] = PyTuple_GET_ITEM(args, i);
    1351             :       }
    1352             :       for (; l < max; ++l) {
    1353             :   objs[l] = 0;
    1354             :       }
    1355             :       return i + 1;
    1356             :     }    
    1357             :   }
    1358             : }
    1359             : 
    1360             : /* A functor is a function object with one single object argument */
    1361             : #if PY_VERSION_HEX >= 0x02020000
    1362             : #define SWIG_Python_CallFunctor(functor, obj)         PyObject_CallFunctionObjArgs(functor, obj, NULL);
    1363             : #else
    1364             : #define SWIG_Python_CallFunctor(functor, obj)         PyObject_CallFunction(functor, "O", obj);
    1365             : #endif
    1366             : 
    1367             : /*
    1368             :   Helper for static pointer initialization for both C and C++ code, for example
    1369             :   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
    1370             : */
    1371             : #ifdef __cplusplus
    1372             : #define SWIG_STATIC_POINTER(var)  var
    1373             : #else
    1374             : #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
    1375             : #endif
    1376             : 
    1377             : /* -----------------------------------------------------------------------------
    1378             :  * Pointer declarations
    1379             :  * ----------------------------------------------------------------------------- */
    1380             : 
    1381             : /* Flags for new pointer objects */
    1382             : #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
    1383             : #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
    1384             : 
    1385             : #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
    1386             : 
    1387             : #define SWIG_BUILTIN_TP_INIT      (SWIG_POINTER_OWN << 2)
    1388             : #define SWIG_BUILTIN_INIT     (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
    1389             : 
    1390             : #ifdef __cplusplus
    1391             : extern "C" {
    1392             : #endif
    1393             : 
    1394             : /*  How to access Py_None */
    1395             : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
    1396             : #  ifndef SWIG_PYTHON_NO_BUILD_NONE
    1397             : #    ifndef SWIG_PYTHON_BUILD_NONE
    1398             : #      define SWIG_PYTHON_BUILD_NONE
    1399             : #    endif
    1400             : #  endif
    1401             : #endif
    1402             : 
    1403             : #ifdef SWIG_PYTHON_BUILD_NONE
    1404             : #  ifdef Py_None
    1405             : #   undef Py_None
    1406             : #   define Py_None SWIG_Py_None()
    1407             : #  endif
    1408             : SWIGRUNTIMEINLINE PyObject * 
    1409             : _SWIG_Py_None(void)
    1410             : {
    1411             :   PyObject *none = Py_BuildValue((char*)"");
    1412             :   Py_DECREF(none);
    1413             :   return none;
    1414             : }
    1415             : SWIGRUNTIME PyObject * 
    1416             : SWIG_Py_None(void)
    1417             : {
    1418             :   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
    1419             :   return none;
    1420             : }
    1421             : #endif
    1422             : 
    1423             : /* The python void return value */
    1424             : 
    1425             : SWIGRUNTIMEINLINE PyObject * 
    1426             : SWIG_Py_Void(void)
    1427             : {
    1428             :   PyObject *none = Py_None;
    1429           1 :   Py_INCREF(none);
    1430             :   return none;
    1431             : }
    1432             : 
    1433             : /* SwigPyClientData */
    1434             : 
    1435             : typedef struct {
    1436             :   PyObject *klass;
    1437             :   PyObject *newraw;
    1438             :   PyObject *newargs;
    1439             :   PyObject *destroy;
    1440             :   int delargs;
    1441             :   int implicitconv;
    1442             :   PyTypeObject *pytype;
    1443             : } SwigPyClientData;
    1444             : 
    1445             : SWIGRUNTIMEINLINE int 
    1446             : SWIG_Python_CheckImplicit(swig_type_info *ty)
    1447             : {
    1448             :   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
    1449             :   return data ? data->implicitconv : 0;
    1450             : }
    1451             : 
    1452             : SWIGRUNTIMEINLINE PyObject *
    1453             : SWIG_Python_ExceptionType(swig_type_info *desc) {
    1454             :   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
    1455             :   PyObject *klass = data ? data->klass : 0;
    1456             :   return (klass ? klass : PyExc_RuntimeError);
    1457             : }
    1458             : 
    1459             : 
    1460             : SWIGRUNTIME SwigPyClientData * 
    1461           1 : SwigPyClientData_New(PyObject* obj)
    1462             : {
    1463           1 :   if (!obj) {
    1464             :     return 0;
    1465             :   } else {
    1466           1 :     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    1467             :     /* the klass element */
    1468           1 :     data->klass = obj;
    1469           1 :     Py_INCREF(data->klass);
    1470             :     /* the newraw method and newargs arguments used to create a new raw instance */
    1471           1 :     if (PyClass_Check(obj)) {
    1472           1 :       data->newraw = 0;
    1473           1 :       data->newargs = obj;
    1474           1 :       Py_INCREF(obj);
    1475             :     } else {
    1476             : #if (PY_VERSION_HEX < 0x02020000)
    1477             :       data->newraw = 0;
    1478             : #else
    1479           0 :       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
    1480             : #endif
    1481           0 :       if (data->newraw) {
    1482           0 :   Py_INCREF(data->newraw);
    1483           0 :   data->newargs = PyTuple_New(1);
    1484           0 :   PyTuple_SetItem(data->newargs, 0, obj);
    1485             :       } else {
    1486           0 :   data->newargs = obj;
    1487             :       }
    1488           0 :       Py_INCREF(data->newargs);
    1489             :     }
    1490             :     /* the destroy method, aka as the C++ delete method */
    1491           1 :     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    1492           1 :     if (PyErr_Occurred()) {
    1493           0 :       PyErr_Clear();
    1494           0 :       data->destroy = 0;
    1495             :     }
    1496           1 :     if (data->destroy) {
    1497             :       int flags;
    1498           1 :       Py_INCREF(data->destroy);
    1499           1 :       flags = PyCFunction_GET_FLAGS(data->destroy);
    1500             : #ifdef METH_O
    1501           1 :       data->delargs = !(flags & (METH_O));
    1502             : #else
    1503             :       data->delargs = 0;
    1504             : #endif
    1505             :     } else {
    1506           0 :       data->delargs = 0;
    1507             :     }
    1508           1 :     data->implicitconv = 0;
    1509           1 :     data->pytype = 0;
    1510           1 :     return data;
    1511             :   }
    1512             : }
    1513             : 
    1514             : SWIGRUNTIME void 
    1515           1 : SwigPyClientData_Del(SwigPyClientData *data) {
    1516           1 :   Py_XDECREF(data->newraw);
    1517           1 :   Py_XDECREF(data->newargs);
    1518           1 :   Py_XDECREF(data->destroy);
    1519           1 : }
    1520             : 
    1521             : /* =============== SwigPyObject =====================*/
    1522             : 
    1523             : typedef struct {
    1524             :   PyObject_HEAD
    1525             :   void *ptr;
    1526             :   swig_type_info *ty;
    1527             :   int own;
    1528             :   PyObject *next;
    1529             : #ifdef SWIGPYTHON_BUILTIN
    1530             :   PyObject *dict;
    1531             : #endif
    1532             : } SwigPyObject;
    1533             : 
    1534             : 
    1535             : #ifdef SWIGPYTHON_BUILTIN
    1536             : 
    1537             : SWIGRUNTIME PyObject *
    1538             : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
    1539             : {
    1540             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1541             : 
    1542             :   if (!sobj->dict)
    1543             :     sobj->dict = PyDict_New();
    1544             : 
    1545             :   Py_INCREF(sobj->dict);
    1546             :   return sobj->dict;
    1547             : }
    1548             : 
    1549             : #endif
    1550             : 
    1551             : SWIGRUNTIME PyObject *
    1552           0 : SwigPyObject_long(SwigPyObject *v)
    1553             : {
    1554           0 :   return PyLong_FromVoidPtr(v->ptr);
    1555             : }
    1556             : 
    1557             : SWIGRUNTIME PyObject *
    1558             : SwigPyObject_format(const char* fmt, SwigPyObject *v)
    1559             : {
    1560             :   PyObject *res = NULL;
    1561             :   PyObject *args = PyTuple_New(1);
    1562             :   if (args) {
    1563             :     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
    1564             :       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
    1565             :       if (ofmt) {
    1566             : #if PY_VERSION_HEX >= 0x03000000
    1567             :   res = PyUnicode_Format(ofmt,args);
    1568             : #else
    1569             :   res = PyString_Format(ofmt,args);
    1570             : #endif
    1571             :   Py_DECREF(ofmt);
    1572             :       }
    1573             :       Py_DECREF(args);
    1574             :     }
    1575             :   }
    1576             :   return res;
    1577             : }
    1578             : 
    1579             : SWIGRUNTIME PyObject *
    1580             : SwigPyObject_oct(SwigPyObject *v)
    1581             : {
    1582             :   return SwigPyObject_format("%o",v);
    1583             : }
    1584             : 
    1585             : SWIGRUNTIME PyObject *
    1586             : SwigPyObject_hex(SwigPyObject *v)
    1587             : {
    1588             :   return SwigPyObject_format("%x",v);
    1589             : }
    1590             : 
    1591             : SWIGRUNTIME PyObject *
    1592             : #ifdef METH_NOARGS
    1593           1 : SwigPyObject_repr(SwigPyObject *v)
    1594             : #else
    1595             : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
    1596             : #endif
    1597             : {
    1598           1 :   const char *name = SWIG_TypePrettyName(v->ty);
    1599           1 :   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
    1600           1 :   if (v->next) {
    1601             : # ifdef METH_NOARGS
    1602           0 :     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    1603             : # else
    1604             :     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
    1605             : # endif
    1606             : # if PY_VERSION_HEX >= 0x03000000
    1607           0 :     PyObject *joined = PyUnicode_Concat(repr, nrep);
    1608           0 :     Py_DecRef(repr);
    1609           0 :     Py_DecRef(nrep);
    1610             :     repr = joined;
    1611             : # else
    1612             :     PyString_ConcatAndDel(&repr,nrep);
    1613             : # endif
    1614             :   }
    1615           1 :   return repr;  
    1616             : }
    1617             : 
    1618             : SWIGRUNTIME int
    1619             : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
    1620             : {
    1621             :   void *i = v->ptr;
    1622             :   void *j = w->ptr;
    1623           0 :   return (i < j) ? -1 : ((i > j) ? 1 : 0);
    1624             : }
    1625             : 
    1626             : /* Added for Python 3.x, would it also be useful for Python 2.x? */
    1627             : SWIGRUNTIME PyObject*
    1628           0 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
    1629             : {
    1630             :   PyObject* res;
    1631           0 :   if( op != Py_EQ && op != Py_NE ) {
    1632           0 :     Py_INCREF(Py_NotImplemented);
    1633           0 :     return Py_NotImplemented;
    1634             :   }
    1635           0 :   res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
    1636           0 :   return res;  
    1637             : }
    1638             : 
    1639             : 
    1640             : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
    1641             : 
    1642             : #ifdef SWIGPYTHON_BUILTIN
    1643             : static swig_type_info *SwigPyObject_stype = 0;
    1644             : SWIGRUNTIME PyTypeObject*
    1645             : SwigPyObject_type(void) {
    1646             :     SwigPyClientData *cd;
    1647             :     assert(SwigPyObject_stype);
    1648             :     cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    1649             :     assert(cd);
    1650             :     assert(cd->pytype);
    1651             :     return cd->pytype;
    1652             : }
    1653             : #else
    1654             : SWIGRUNTIME PyTypeObject*
    1655             : SwigPyObject_type(void) {
    1656           1 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
    1657           1 :   return type;
    1658             : }
    1659             : #endif
    1660             : 
    1661             : SWIGRUNTIMEINLINE int
    1662           1 : SwigPyObject_Check(PyObject *op) {
    1663             : #ifdef SWIGPYTHON_BUILTIN
    1664             :   PyTypeObject *target_tp = SwigPyObject_type();
    1665             :   if (PyType_IsSubtype(op->ob_type, target_tp))
    1666             :     return 1;
    1667             :   return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
    1668             : #else
    1669           1 :   return (Py_TYPE(op) == SwigPyObject_type())
    1670           1 :     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
    1671             : #endif
    1672             : }
    1673             : 
    1674             : SWIGRUNTIME PyObject *
    1675             : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
    1676             : 
    1677             : SWIGRUNTIME void
    1678           1 : SwigPyObject_dealloc(PyObject *v)
    1679             : {
    1680             :   SwigPyObject *sobj = (SwigPyObject *) v;
    1681           1 :   PyObject *next = sobj->next;
    1682           1 :   if (sobj->own == SWIG_POINTER_OWN) {
    1683           1 :     swig_type_info *ty = sobj->ty;
    1684           1 :     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    1685           1 :     PyObject *destroy = data ? data->destroy : 0;
    1686           1 :     if (destroy) {
    1687             :       /* destroy is always a VARARGS method */
    1688             :       PyObject *res;
    1689             : 
    1690             :       /* PyObject_CallFunction() has the potential to silently drop
    1691             :          the active active exception.  In cases of unnamed temporary
    1692             :          variable or where we just finished iterating over a generator
    1693             :          StopIteration will be active right now, and this needs to
    1694             :          remain true upon return from SwigPyObject_dealloc.  So save
    1695             :          and restore. */
    1696             :       
    1697           1 :       PyObject *val = NULL, *type = NULL, *tb = NULL;
    1698           1 :       PyErr_Fetch(&val, &type, &tb);
    1699             : 
    1700           1 :       if (data->delargs) {
    1701             :         /* we need to create a temporary object to carry the destroy operation */
    1702           1 :         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
    1703           1 :         res = SWIG_Python_CallFunctor(destroy, tmp);
    1704           1 :         Py_DECREF(tmp);
    1705             :       } else {
    1706           0 :         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
    1707           0 :         PyObject *mself = PyCFunction_GET_SELF(destroy);
    1708           0 :         res = ((*meth)(mself, v));
    1709             :       }
    1710           1 :       if (!res)
    1711           0 :         PyErr_WriteUnraisable(destroy);
    1712             : 
    1713           1 :       PyErr_Restore(val, type, tb);
    1714             : 
    1715           1 :       Py_XDECREF(res);
    1716             :     } 
    1717             : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    1718             :     else {
    1719             :       const char *name = SWIG_TypePrettyName(ty);
    1720           0 :       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    1721             :     }
    1722             : #endif
    1723             :   } 
    1724           1 :   Py_XDECREF(next);
    1725           1 :   PyObject_DEL(v);
    1726           1 : }
    1727             : 
    1728             : SWIGRUNTIME PyObject* 
    1729           0 : SwigPyObject_append(PyObject* v, PyObject* next)
    1730             : {
    1731             :   SwigPyObject *sobj = (SwigPyObject *) v;
    1732             : #ifndef METH_O
    1733             :   PyObject *tmp = 0;
    1734             :   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
    1735             :   next = tmp;
    1736             : #endif
    1737           0 :   if (!SwigPyObject_Check(next)) {
    1738           0 :     PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    1739           0 :     return NULL;
    1740             :   }
    1741           0 :   sobj->next = next;
    1742           0 :   Py_INCREF(next);
    1743           0 :   return SWIG_Py_Void();
    1744             : }
    1745             : 
    1746             : SWIGRUNTIME PyObject* 
    1747             : #ifdef METH_NOARGS
    1748           0 : SwigPyObject_next(PyObject* v)
    1749             : #else
    1750             : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1751             : #endif
    1752             : {
    1753             :   SwigPyObject *sobj = (SwigPyObject *) v;
    1754           0 :   if (sobj->next) {    
    1755           0 :     Py_INCREF(sobj->next);
    1756           0 :     return sobj->next;
    1757             :   } else {
    1758           0 :     return SWIG_Py_Void();
    1759             :   }
    1760             : }
    1761             : 
    1762             : SWIGINTERN PyObject*
    1763             : #ifdef METH_NOARGS
    1764           0 : SwigPyObject_disown(PyObject *v)
    1765             : #else
    1766             : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1767             : #endif
    1768             : {
    1769             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1770           0 :   sobj->own = 0;
    1771           0 :   return SWIG_Py_Void();
    1772             : }
    1773             : 
    1774             : SWIGINTERN PyObject*
    1775             : #ifdef METH_NOARGS
    1776           0 : SwigPyObject_acquire(PyObject *v)
    1777             : #else
    1778             : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1779             : #endif
    1780             : {
    1781             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1782           0 :   sobj->own = SWIG_POINTER_OWN;
    1783           0 :   return SWIG_Py_Void();
    1784             : }
    1785             : 
    1786             : SWIGINTERN PyObject*
    1787           1 : SwigPyObject_own(PyObject *v, PyObject *args)
    1788             : {
    1789           1 :   PyObject *val = 0;
    1790             : #if (PY_VERSION_HEX < 0x02020000)
    1791             :   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
    1792             : #elif (PY_VERSION_HEX < 0x02050000)
    1793             :   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
    1794             : #else
    1795           1 :   if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
    1796             : #endif
    1797             :     {
    1798             :       return NULL;
    1799             :     } 
    1800             :   else
    1801             :     {
    1802             :       SwigPyObject *sobj = (SwigPyObject *)v;
    1803           1 :       PyObject *obj = PyBool_FromLong(sobj->own);
    1804           1 :       if (val) {
    1805             : #ifdef METH_NOARGS
    1806           0 :   if (PyObject_IsTrue(val)) {
    1807             :     SwigPyObject_acquire(v);
    1808             :   } else {
    1809             :     SwigPyObject_disown(v);
    1810             :   }
    1811             : #else
    1812             :   if (PyObject_IsTrue(val)) {
    1813             :     SwigPyObject_acquire(v,args);
    1814             :   } else {
    1815             :     SwigPyObject_disown(v,args);
    1816             :   }
    1817             : #endif
    1818             :       } 
    1819             :       return obj;
    1820             :     }
    1821             : }
    1822             : 
    1823             : #ifdef METH_O
    1824             : static PyMethodDef
    1825             : swigobject_methods[] = {
    1826             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
    1827             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
    1828             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
    1829             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
    1830             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
    1831             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
    1832             :   {0, 0, 0, 0}  
    1833             : };
    1834             : #else
    1835             : static PyMethodDef
    1836             : swigobject_methods[] = {
    1837             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
    1838             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
    1839             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
    1840             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
    1841             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
    1842             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
    1843             :   {0, 0, 0, 0}  
    1844             : };
    1845             : #endif
    1846             : 
    1847             : #if PY_VERSION_HEX < 0x02020000
    1848             : SWIGINTERN PyObject *
    1849             : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
    1850             : {
    1851             :   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
    1852             : }
    1853             : #endif
    1854             : 
    1855             : SWIGRUNTIME PyTypeObject*
    1856           1 : SwigPyObject_TypeOnce(void) {
    1857             :   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
    1858             : 
    1859             :   static PyNumberMethods SwigPyObject_as_number = {
    1860             :     (binaryfunc)0, /*nb_add*/
    1861             :     (binaryfunc)0, /*nb_subtract*/
    1862             :     (binaryfunc)0, /*nb_multiply*/
    1863             :     /* nb_divide removed in Python 3 */
    1864             : #if PY_VERSION_HEX < 0x03000000
    1865             :     (binaryfunc)0, /*nb_divide*/
    1866             : #endif
    1867             :     (binaryfunc)0, /*nb_remainder*/
    1868             :     (binaryfunc)0, /*nb_divmod*/
    1869             :     (ternaryfunc)0,/*nb_power*/
    1870             :     (unaryfunc)0,  /*nb_negative*/
    1871             :     (unaryfunc)0,  /*nb_positive*/
    1872             :     (unaryfunc)0,  /*nb_absolute*/
    1873             :     (inquiry)0,    /*nb_nonzero*/
    1874             :     0,       /*nb_invert*/
    1875             :     0,       /*nb_lshift*/
    1876             :     0,       /*nb_rshift*/
    1877             :     0,       /*nb_and*/
    1878             :     0,       /*nb_xor*/
    1879             :     0,       /*nb_or*/
    1880             : #if PY_VERSION_HEX < 0x03000000
    1881             :     0,   /*nb_coerce*/
    1882             : #endif
    1883             :     (unaryfunc)SwigPyObject_long, /*nb_int*/
    1884             : #if PY_VERSION_HEX < 0x03000000
    1885             :     (unaryfunc)SwigPyObject_long, /*nb_long*/
    1886             : #else
    1887             :     0, /*nb_reserved*/
    1888             : #endif
    1889             :     (unaryfunc)0,                 /*nb_float*/
    1890             : #if PY_VERSION_HEX < 0x03000000
    1891             :     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    1892             :     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
    1893             : #endif
    1894             : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    1895             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
    1896             : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    1897             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
    1898             : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    1899             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
    1900             : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    1901             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
    1902             : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    1903             :     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
    1904             : #endif
    1905             :   };
    1906             : 
    1907             :   static PyTypeObject swigpyobject_type;
    1908             :   static int type_init = 0;
    1909           1 :   if (!type_init) {
    1910             :     const PyTypeObject tmp = {
    1911             : #if PY_VERSION_HEX >= 0x03000000
    1912             :       PyVarObject_HEAD_INIT(NULL, 0)
    1913             : #else
    1914             :       PyObject_HEAD_INIT(NULL)
    1915             :       0,                                    /* ob_size */
    1916             : #endif
    1917             :       (char *)"SwigPyObject",               /* tp_name */
    1918             :       sizeof(SwigPyObject),                 /* tp_basicsize */
    1919             :       0,                                    /* tp_itemsize */
    1920             :       (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
    1921             :       0,                                    /* tp_print */
    1922             : #if PY_VERSION_HEX < 0x02020000
    1923             :       (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
    1924             : #else
    1925             :       (getattrfunc)0,                       /* tp_getattr */
    1926             : #endif
    1927             :       (setattrfunc)0,                       /* tp_setattr */
    1928             : #if PY_VERSION_HEX >= 0x03000000
    1929             :       0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
    1930             : #else
    1931             :       (cmpfunc)SwigPyObject_compare,        /* tp_compare */
    1932             : #endif
    1933             :       (reprfunc)SwigPyObject_repr,          /* tp_repr */
    1934             :       &SwigPyObject_as_number,              /* tp_as_number */
    1935             :       0,                                    /* tp_as_sequence */
    1936             :       0,                                    /* tp_as_mapping */
    1937             :       (hashfunc)0,                          /* tp_hash */
    1938             :       (ternaryfunc)0,                       /* tp_call */
    1939             :       0,                                    /* tp_str */
    1940             :       PyObject_GenericGetAttr,              /* tp_getattro */
    1941             :       0,                                    /* tp_setattro */
    1942             :       0,                                    /* tp_as_buffer */
    1943             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    1944             :       swigobject_doc,                       /* tp_doc */
    1945             :       0,                                    /* tp_traverse */
    1946             :       0,                                    /* tp_clear */
    1947             :       (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
    1948             :       0,                                    /* tp_weaklistoffset */
    1949             : #if PY_VERSION_HEX >= 0x02020000
    1950             :       0,                                    /* tp_iter */
    1951             :       0,                                    /* tp_iternext */
    1952             :       swigobject_methods,                   /* tp_methods */
    1953             :       0,                                    /* tp_members */
    1954             :       0,                                    /* tp_getset */
    1955             :       0,                                    /* tp_base */
    1956             :       0,                                    /* tp_dict */
    1957             :       0,                                    /* tp_descr_get */
    1958             :       0,                                    /* tp_descr_set */
    1959             :       0,                                    /* tp_dictoffset */
    1960             :       0,                                    /* tp_init */
    1961             :       0,                                    /* tp_alloc */
    1962             :       0,                                    /* tp_new */
    1963             :       0,                                    /* tp_free */
    1964             :       0,                                    /* tp_is_gc */
    1965             :       0,                                    /* tp_bases */
    1966             :       0,                                    /* tp_mro */
    1967             :       0,                                    /* tp_cache */
    1968             :       0,                                    /* tp_subclasses */
    1969             :       0,                                    /* tp_weaklist */
    1970             : #endif
    1971             : #if PY_VERSION_HEX >= 0x02030000
    1972             :       0,                                    /* tp_del */
    1973             : #endif
    1974             : #if PY_VERSION_HEX >= 0x02060000
    1975             :       0,                                    /* tp_version_tag */
    1976             : #endif
    1977             : #if PY_VERSION_HEX >= 0x03040000
    1978             :       0,                                    /* tp_finalize */
    1979             : #endif
    1980             : #ifdef COUNT_ALLOCS
    1981             :       0,                                    /* tp_allocs */
    1982             :       0,                                    /* tp_frees */
    1983             :       0,                                    /* tp_maxalloc */
    1984             : #if PY_VERSION_HEX >= 0x02050000
    1985             :       0,                                    /* tp_prev */
    1986             : #endif
    1987             :       0                                     /* tp_next */
    1988             : #endif
    1989             :     };
    1990           1 :     swigpyobject_type = tmp;
    1991           1 :     type_init = 1;
    1992             : #if PY_VERSION_HEX < 0x02020000
    1993             :     swigpyobject_type.ob_type = &PyType_Type;
    1994             : #else
    1995           1 :     if (PyType_Ready(&swigpyobject_type) < 0)
    1996             :       return NULL;
    1997             : #endif
    1998             :   }
    1999             :   return &swigpyobject_type;
    2000             : }
    2001             : 
    2002             : SWIGRUNTIME PyObject *
    2003           1 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
    2004             : {
    2005           1 :   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
    2006           1 :   if (sobj) {
    2007           1 :     sobj->ptr  = ptr;
    2008           1 :     sobj->ty   = ty;
    2009           1 :     sobj->own  = own;
    2010           1 :     sobj->next = 0;
    2011             :   }
    2012           1 :   return (PyObject *)sobj;
    2013             : }
    2014             : 
    2015             : /* -----------------------------------------------------------------------------
    2016             :  * Implements a simple Swig Packed type, and use it instead of string
    2017             :  * ----------------------------------------------------------------------------- */
    2018             : 
    2019             : typedef struct {
    2020             :   PyObject_HEAD
    2021             :   void *pack;
    2022             :   swig_type_info *ty;
    2023             :   size_t size;
    2024             : } SwigPyPacked;
    2025             : 
    2026             : SWIGRUNTIME int
    2027           0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
    2028             : {
    2029             :   char result[SWIG_BUFFER_SIZE];
    2030           0 :   fputs("<Swig Packed ", fp); 
    2031           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2032           0 :     fputs("at ", fp); 
    2033           0 :     fputs(result, fp); 
    2034             :   }
    2035           0 :   fputs(v->ty->name,fp); 
    2036           0 :   fputs(">", fp);
    2037           0 :   return 0; 
    2038             : }
    2039             :   
    2040             : SWIGRUNTIME PyObject *
    2041           0 : SwigPyPacked_repr(SwigPyPacked *v)
    2042             : {
    2043             :   char result[SWIG_BUFFER_SIZE];
    2044           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2045           0 :     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
    2046             :   } else {
    2047           0 :     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
    2048             :   }  
    2049             : }
    2050             : 
    2051             : SWIGRUNTIME PyObject *
    2052           0 : SwigPyPacked_str(SwigPyPacked *v)
    2053             : {
    2054             :   char result[SWIG_BUFFER_SIZE];
    2055           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    2056           0 :     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
    2057             :   } else {
    2058           0 :     return SWIG_Python_str_FromChar(v->ty->name);
    2059             :   }  
    2060             : }
    2061             : 
    2062             : SWIGRUNTIME int
    2063             : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
    2064             : {
    2065             :   size_t i = v->size;
    2066             :   size_t j = w->size;
    2067             :   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
    2068             :   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
    2069             : }
    2070             : 
    2071             : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
    2072             : 
    2073             : SWIGRUNTIME PyTypeObject*
    2074             : SwigPyPacked_type(void) {
    2075           0 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
    2076           0 :   return type;
    2077             : }
    2078             : 
    2079             : SWIGRUNTIMEINLINE int
    2080           0 : SwigPyPacked_Check(PyObject *op) {
    2081           0 :   return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    2082           0 :     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
    2083             : }
    2084             : 
    2085             : SWIGRUNTIME void
    2086           0 : SwigPyPacked_dealloc(PyObject *v)
    2087             : {
    2088           0 :   if (SwigPyPacked_Check(v)) {
    2089             :     SwigPyPacked *sobj = (SwigPyPacked *) v;
    2090           0 :     free(sobj->pack);
    2091             :   }
    2092           0 :   PyObject_DEL(v);
    2093           0 : }
    2094             : 
    2095             : SWIGRUNTIME PyTypeObject*
    2096           0 : SwigPyPacked_TypeOnce(void) {
    2097             :   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
    2098             :   static PyTypeObject swigpypacked_type;
    2099             :   static int type_init = 0;
    2100           0 :   if (!type_init) {
    2101             :     const PyTypeObject tmp = {
    2102             : #if PY_VERSION_HEX>=0x03000000
    2103             :       PyVarObject_HEAD_INIT(NULL, 0)
    2104             : #else
    2105             :       PyObject_HEAD_INIT(NULL)
    2106             :       0,                                    /* ob_size */
    2107             : #endif
    2108             :       (char *)"SwigPyPacked",               /* tp_name */
    2109             :       sizeof(SwigPyPacked),                 /* tp_basicsize */
    2110             :       0,                                    /* tp_itemsize */
    2111             :       (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
    2112             :       (printfunc)SwigPyPacked_print,        /* tp_print */
    2113             :       (getattrfunc)0,                       /* tp_getattr */
    2114             :       (setattrfunc)0,                       /* tp_setattr */
    2115             : #if PY_VERSION_HEX>=0x03000000
    2116             :       0, /* tp_reserved in 3.0.1 */
    2117             : #else
    2118             :       (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
    2119             : #endif
    2120             :       (reprfunc)SwigPyPacked_repr,          /* tp_repr */
    2121             :       0,                                    /* tp_as_number */
    2122             :       0,                                    /* tp_as_sequence */
    2123             :       0,                                    /* tp_as_mapping */
    2124             :       (hashfunc)0,                          /* tp_hash */
    2125             :       (ternaryfunc)0,                       /* tp_call */
    2126             :       (reprfunc)SwigPyPacked_str,           /* tp_str */
    2127             :       PyObject_GenericGetAttr,              /* tp_getattro */
    2128             :       0,                                    /* tp_setattro */
    2129             :       0,                                    /* tp_as_buffer */
    2130             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    2131             :       swigpacked_doc,                       /* tp_doc */
    2132             :       0,                                    /* tp_traverse */
    2133             :       0,                                    /* tp_clear */
    2134             :       0,                                    /* tp_richcompare */
    2135             :       0,                                    /* tp_weaklistoffset */
    2136             : #if PY_VERSION_HEX >= 0x02020000
    2137             :       0,                                    /* tp_iter */
    2138             :       0,                                    /* tp_iternext */
    2139             :       0,                                    /* tp_methods */
    2140             :       0,                                    /* tp_members */
    2141             :       0,                                    /* tp_getset */
    2142             :       0,                                    /* tp_base */
    2143             :       0,                                    /* tp_dict */
    2144             :       0,                                    /* tp_descr_get */
    2145             :       0,                                    /* tp_descr_set */
    2146             :       0,                                    /* tp_dictoffset */
    2147             :       0,                                    /* tp_init */
    2148             :       0,                                    /* tp_alloc */
    2149             :       0,                                    /* tp_new */
    2150             :       0,                                    /* tp_free */
    2151             :       0,                                    /* tp_is_gc */
    2152             :       0,                                    /* tp_bases */
    2153             :       0,                                    /* tp_mro */
    2154             :       0,                                    /* tp_cache */
    2155             :       0,                                    /* tp_subclasses */
    2156             :       0,                                    /* tp_weaklist */
    2157             : #endif
    2158             : #if PY_VERSION_HEX >= 0x02030000
    2159             :       0,                                    /* tp_del */
    2160             : #endif
    2161             : #if PY_VERSION_HEX >= 0x02060000
    2162             :       0,                                    /* tp_version_tag */
    2163             : #endif
    2164             : #if PY_VERSION_HEX >= 0x03040000
    2165             :       0,                                    /* tp_finalize */
    2166             : #endif
    2167             : #ifdef COUNT_ALLOCS
    2168             :       0,                                    /* tp_allocs */
    2169             :       0,                                    /* tp_frees */
    2170             :       0,                                    /* tp_maxalloc */
    2171             : #if PY_VERSION_HEX >= 0x02050000
    2172             :       0,                                    /* tp_prev */
    2173             : #endif
    2174             :       0                                     /* tp_next */
    2175             : #endif
    2176             :     };
    2177           0 :     swigpypacked_type = tmp;
    2178           0 :     type_init = 1;
    2179             : #if PY_VERSION_HEX < 0x02020000
    2180             :     swigpypacked_type.ob_type = &PyType_Type;
    2181             : #else
    2182           0 :     if (PyType_Ready(&swigpypacked_type) < 0)
    2183             :       return NULL;
    2184             : #endif
    2185             :   }
    2186             :   return &swigpypacked_type;
    2187             : }
    2188             : 
    2189             : SWIGRUNTIME PyObject *
    2190           0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
    2191             : {
    2192           0 :   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
    2193           0 :   if (sobj) {
    2194           0 :     void *pack = malloc(size);
    2195           0 :     if (pack) {
    2196             :       memcpy(pack, ptr, size);
    2197           0 :       sobj->pack = pack;
    2198           0 :       sobj->ty   = ty;
    2199           0 :       sobj->size = size;
    2200             :     } else {
    2201           0 :       PyObject_DEL((PyObject *) sobj);
    2202             :       sobj = 0;
    2203             :     }
    2204             :   }
    2205           0 :   return (PyObject *) sobj;
    2206             : }
    2207             : 
    2208             : SWIGRUNTIME swig_type_info *
    2209             : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
    2210             : {
    2211             :   if (SwigPyPacked_Check(obj)) {
    2212             :     SwigPyPacked *sobj = (SwigPyPacked *)obj;
    2213             :     if (sobj->size != size) return 0;
    2214             :     memcpy(ptr, sobj->pack, size);
    2215             :     return sobj->ty;
    2216             :   } else {
    2217             :     return 0;
    2218             :   }
    2219             : }
    2220             : 
    2221             : /* -----------------------------------------------------------------------------
    2222             :  * pointers/data manipulation
    2223             :  * ----------------------------------------------------------------------------- */
    2224             : 
    2225             : SWIGRUNTIMEINLINE PyObject *
    2226             : _SWIG_This(void)
    2227             : {
    2228             :     return SWIG_Python_str_FromChar("this");
    2229             : }
    2230             : 
    2231             : static PyObject *swig_this = NULL;
    2232             : 
    2233             : SWIGRUNTIME PyObject *
    2234             : SWIG_This(void)
    2235             : {
    2236           1 :   if (swig_this == NULL)
    2237           1 :     swig_this = _SWIG_This();
    2238           1 :   return swig_this;
    2239             : }
    2240             : 
    2241             : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
    2242             : 
    2243             : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
    2244             : #if PY_VERSION_HEX>=0x03000000
    2245             : #define SWIG_PYTHON_SLOW_GETSET_THIS 
    2246             : #endif
    2247             : 
    2248             : SWIGRUNTIME SwigPyObject *
    2249           1 : SWIG_Python_GetSwigThis(PyObject *pyobj) 
    2250             : {
    2251             :   PyObject *obj;
    2252             : 
    2253           1 :   if (SwigPyObject_Check(pyobj))
    2254             :     return (SwigPyObject *) pyobj;
    2255             : 
    2256             : #ifdef SWIGPYTHON_BUILTIN
    2257             :   (void)obj;
    2258             : # ifdef PyWeakref_CheckProxy
    2259             :   if (PyWeakref_CheckProxy(pyobj)) {
    2260             :     pyobj = PyWeakref_GET_OBJECT(pyobj);
    2261             :     if (pyobj && SwigPyObject_Check(pyobj))
    2262             :       return (SwigPyObject*) pyobj;
    2263             :   }
    2264             : # endif
    2265             :   return NULL;
    2266             : #else
    2267             : 
    2268             :   obj = 0;
    2269             : 
    2270             : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
    2271             :   if (PyInstance_Check(pyobj)) {
    2272             :     obj = _PyInstance_Lookup(pyobj, SWIG_This());      
    2273             :   } else {
    2274             :     PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    2275             :     if (dictptr != NULL) {
    2276             :       PyObject *dict = *dictptr;
    2277             :       obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    2278             :     } else {
    2279             : #ifdef PyWeakref_CheckProxy
    2280             :       if (PyWeakref_CheckProxy(pyobj)) {
    2281             :   PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
    2282             :   return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
    2283             :       }
    2284             : #endif
    2285             :       obj = PyObject_GetAttr(pyobj,SWIG_This());
    2286             :       if (obj) {
    2287             :   Py_DECREF(obj);
    2288             :       } else {
    2289             :   if (PyErr_Occurred()) PyErr_Clear();
    2290             :   return 0;
    2291             :       }
    2292             :     }
    2293             :   }
    2294             : #else
    2295           1 :   obj = PyObject_GetAttr(pyobj,SWIG_This());
    2296           1 :   if (obj) {
    2297           1 :     Py_DECREF(obj);
    2298             :   } else {
    2299           0 :     if (PyErr_Occurred()) PyErr_Clear();
    2300             :     return 0;
    2301             :   }
    2302             : #endif
    2303           1 :   if (obj && !SwigPyObject_Check(obj)) {
    2304             :     /* a PyObject is called 'this', try to get the 'real this'
    2305             :        SwigPyObject from it */ 
    2306             :     return SWIG_Python_GetSwigThis(obj);
    2307             :   }
    2308             :   return (SwigPyObject *)obj;
    2309             : #endif
    2310             : }
    2311             : 
    2312             : /* Acquire a pointer value */
    2313             : 
    2314             : SWIGRUNTIME int
    2315             : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
    2316             :   if (own == SWIG_POINTER_OWN) {
    2317             :     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    2318             :     if (sobj) {
    2319             :       int oldown = sobj->own;
    2320             :       sobj->own = own;
    2321             :       return oldown;
    2322             :     }
    2323             :   }
    2324             :   return 0;
    2325             : }
    2326             : 
    2327             : /* Convert a pointer value */
    2328             : 
    2329             : SWIGRUNTIME int
    2330           1 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
    2331             :   int res;
    2332             :   SwigPyObject *sobj;
    2333           1 :   int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
    2334             : 
    2335           1 :   if (!obj)
    2336             :     return SWIG_ERROR;
    2337           1 :   if (obj == Py_None && !implicit_conv) {
    2338           1 :     if (ptr)
    2339           1 :       *ptr = 0;
    2340             :     return SWIG_OK;
    2341             :   }
    2342             : 
    2343             :   res = SWIG_ERROR;
    2344             : 
    2345           1 :   sobj = SWIG_Python_GetSwigThis(obj);
    2346           1 :   if (own)
    2347           0 :     *own = 0;
    2348           1 :   while (sobj) {
    2349           1 :     void *vptr = sobj->ptr;
    2350           1 :     if (ty) {
    2351           1 :       swig_type_info *to = sobj->ty;
    2352           1 :       if (to == ty) {
    2353             :         /* no type cast needed */
    2354           1 :         if (ptr) *ptr = vptr;
    2355             :         break;
    2356             :       } else {
    2357           0 :         swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2358           0 :         if (!tc) {
    2359           0 :           sobj = (SwigPyObject *)sobj->next;
    2360             :         } else {
    2361           0 :           if (ptr) {
    2362           0 :             int newmemory = 0;
    2363           0 :             *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2364           0 :             if (newmemory == SWIG_CAST_NEW_MEMORY) {
    2365             :               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
    2366           0 :               if (own)
    2367           0 :                 *own = *own | SWIG_CAST_NEW_MEMORY;
    2368             :             }
    2369             :           }
    2370             :           break;
    2371             :         }
    2372             :       }
    2373             :     } else {
    2374           0 :       if (ptr) *ptr = vptr;
    2375             :       break;
    2376             :     }
    2377             :   }
    2378           1 :   if (sobj) {
    2379           1 :     if (own)
    2380           0 :       *own = *own | sobj->own;
    2381           1 :     if (flags & SWIG_POINTER_DISOWN) {
    2382           1 :       sobj->own = 0;
    2383             :     }
    2384             :     res = SWIG_OK;
    2385             :   } else {
    2386           0 :     if (implicit_conv) {
    2387           0 :       SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    2388           0 :       if (data && !data->implicitconv) {
    2389           0 :         PyObject *klass = data->klass;
    2390           0 :         if (klass) {
    2391             :           PyObject *impconv;
    2392           0 :           data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
    2393           0 :           impconv = SWIG_Python_CallFunctor(klass, obj);
    2394           0 :           data->implicitconv = 0;
    2395           0 :           if (PyErr_Occurred()) {
    2396           0 :             PyErr_Clear();
    2397             :             impconv = 0;
    2398             :           }
    2399           0 :           if (impconv) {
    2400           0 :             SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
    2401           0 :             if (iobj) {
    2402             :               void *vptr;
    2403           0 :               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
    2404           0 :               if (SWIG_IsOK(res)) {
    2405           0 :                 if (ptr) {
    2406           0 :                   *ptr = vptr;
    2407             :                   /* transfer the ownership to 'ptr' */
    2408           0 :                   iobj->own = 0;
    2409             :                   res = SWIG_AddCast(res);
    2410           0 :                   res = SWIG_AddNewMask(res);
    2411             :                 } else {
    2412             :                   res = SWIG_AddCast(res);        
    2413             :                 }
    2414             :               }
    2415             :             }
    2416           0 :             Py_DECREF(impconv);
    2417             :           }
    2418             :         }
    2419             :       }
    2420             :     }
    2421           0 :     if (!SWIG_IsOK(res) && obj == Py_None) {
    2422           0 :       if (ptr)
    2423           0 :         *ptr = 0;
    2424           0 :       if (PyErr_Occurred())
    2425           0 :         PyErr_Clear();
    2426             :       res = SWIG_OK;
    2427             :     }
    2428             :   }
    2429             :   return res;
    2430             : }
    2431             : 
    2432             : /* Convert a function ptr value */
    2433             : 
    2434             : SWIGRUNTIME int
    2435             : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
    2436             :   if (!PyCFunction_Check(obj)) {
    2437             :     return SWIG_ConvertPtr(obj, ptr, ty, 0);
    2438             :   } else {
    2439             :     void *vptr = 0;
    2440             :     
    2441             :     /* here we get the method pointer for callbacks */
    2442             :     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    2443             :     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    2444             :     if (desc)
    2445             :       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    2446             :     if (!desc) 
    2447             :       return SWIG_ERROR;
    2448             :     if (ty) {
    2449             :       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
    2450             :       if (tc) {
    2451             :         int newmemory = 0;
    2452             :         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2453             :         assert(!newmemory); /* newmemory handling not yet implemented */
    2454             :       } else {
    2455             :         return SWIG_ERROR;
    2456             :       }
    2457             :     } else {
    2458             :       *ptr = vptr;
    2459             :     }
    2460             :     return SWIG_OK;
    2461             :   }
    2462             : }
    2463             : 
    2464             : /* Convert a packed value value */
    2465             : 
    2466             : SWIGRUNTIME int
    2467             : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
    2468             :   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
    2469             :   if (!to) return SWIG_ERROR;
    2470             :   if (ty) {
    2471             :     if (to != ty) {
    2472             :       /* check type cast? */
    2473             :       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2474             :       if (!tc) return SWIG_ERROR;
    2475             :     }
    2476             :   }
    2477             :   return SWIG_OK;
    2478             : }  
    2479             : 
    2480             : /* -----------------------------------------------------------------------------
    2481             :  * Create a new pointer object
    2482             :  * ----------------------------------------------------------------------------- */
    2483             : 
    2484             : /*
    2485             :   Create a new instance object, without calling __init__, and set the
    2486             :   'this' attribute.
    2487             : */
    2488             : 
    2489             : SWIGRUNTIME PyObject* 
    2490           1 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
    2491             : {
    2492             : #if (PY_VERSION_HEX >= 0x02020000)
    2493             :   PyObject *inst = 0;
    2494           1 :   PyObject *newraw = data->newraw;
    2495           1 :   if (newraw) {
    2496           0 :     inst = PyObject_Call(newraw, data->newargs, NULL);
    2497           0 :     if (inst) {
    2498             : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2499             :       PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2500             :       if (dictptr != NULL) {
    2501             :   PyObject *dict = *dictptr;
    2502             :   if (dict == NULL) {
    2503             :     dict = PyDict_New();
    2504             :     *dictptr = dict;
    2505             :     PyDict_SetItem(dict, SWIG_This(), swig_this);
    2506             :   }
    2507             :       }
    2508             : #else
    2509             :       PyObject *key = SWIG_This();
    2510           0 :       PyObject_SetAttr(inst, key, swig_this);
    2511             : #endif
    2512             :     }
    2513             :   } else {
    2514             : #if PY_VERSION_HEX >= 0x03000000
    2515           1 :     inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    2516           1 :     if (inst) {
    2517           1 :       PyObject_SetAttr(inst, SWIG_This(), swig_this);
    2518           1 :       Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    2519             :     }
    2520             : #else
    2521             :     PyObject *dict = PyDict_New();
    2522             :     if (dict) {
    2523             :       PyDict_SetItem(dict, SWIG_This(), swig_this);
    2524             :       inst = PyInstance_NewRaw(data->newargs, dict);
    2525             :       Py_DECREF(dict);
    2526             :     }
    2527             : #endif
    2528             :   }
    2529           1 :   return inst;
    2530             : #else
    2531             : #if (PY_VERSION_HEX >= 0x02010000)
    2532             :   PyObject *inst = 0;
    2533             :   PyObject *dict = PyDict_New();
    2534             :   if (dict) {
    2535             :     PyDict_SetItem(dict, SWIG_This(), swig_this);
    2536             :     inst = PyInstance_NewRaw(data->newargs, dict);
    2537             :     Py_DECREF(dict);
    2538             :   }
    2539             :   return (PyObject *) inst;
    2540             : #else
    2541             :   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
    2542             :   if (inst == NULL) {
    2543             :     return NULL;
    2544             :   }
    2545             :   inst->in_class = (PyClassObject *)data->newargs;
    2546             :   Py_INCREF(inst->in_class);
    2547             :   inst->in_dict = PyDict_New();
    2548             :   if (inst->in_dict == NULL) {
    2549             :     Py_DECREF(inst);
    2550             :     return NULL;
    2551             :   }
    2552             : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
    2553             :   inst->in_weakreflist = NULL;
    2554             : #endif
    2555             : #ifdef Py_TPFLAGS_GC
    2556             :   PyObject_GC_Init(inst);
    2557             : #endif
    2558             :   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
    2559             :   return (PyObject *) inst;
    2560             : #endif
    2561             : #endif
    2562             : }
    2563             : 
    2564             : SWIGRUNTIME void
    2565             : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
    2566             : {
    2567             :  PyObject *dict;
    2568             : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2569             :  PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2570             :  if (dictptr != NULL) {
    2571             :    dict = *dictptr;
    2572             :    if (dict == NULL) {
    2573             :      dict = PyDict_New();
    2574             :      *dictptr = dict;
    2575             :    }
    2576             :    PyDict_SetItem(dict, SWIG_This(), swig_this);
    2577             :    return;
    2578             :  }
    2579             : #endif
    2580             :  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
    2581             :  PyDict_SetItem(dict, SWIG_This(), swig_this);
    2582             :  Py_DECREF(dict);
    2583             : } 
    2584             : 
    2585             : 
    2586             : SWIGINTERN PyObject *
    2587             : SWIG_Python_InitShadowInstance(PyObject *args) {
    2588             :   PyObject *obj[2];
    2589             :   if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    2590             :     return NULL;
    2591             :   } else {
    2592             :     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    2593             :     if (sthis) {
    2594             :       SwigPyObject_append((PyObject*) sthis, obj[1]);
    2595             :     } else {
    2596             :       SWIG_Python_SetSwigThis(obj[0], obj[1]);
    2597             :     }
    2598             :     return SWIG_Py_Void();
    2599             :   }
    2600             : }
    2601             : 
    2602             : /* Create a new pointer object */
    2603             : 
    2604             : SWIGRUNTIME PyObject *
    2605           1 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
    2606             :   SwigPyClientData *clientdata;
    2607             :   PyObject * robj;
    2608             :   int own;
    2609             : 
    2610           1 :   if (!ptr)
    2611           1 :     return SWIG_Py_Void();
    2612             : 
    2613           1 :   clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
    2614           1 :   own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
    2615           1 :   if (clientdata && clientdata->pytype) {
    2616             :     SwigPyObject *newobj;
    2617           0 :     if (flags & SWIG_BUILTIN_TP_INIT) {
    2618             :       newobj = (SwigPyObject*) self;
    2619           0 :       if (newobj->ptr) {
    2620           0 :         PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
    2621           0 :         while (newobj->next)
    2622             :     newobj = (SwigPyObject *) newobj->next;
    2623           0 :         newobj->next = next_self;
    2624             :         newobj = (SwigPyObject *)next_self;
    2625             : #ifdef SWIGPYTHON_BUILTIN
    2626             :         newobj->dict = 0;
    2627             : #endif
    2628             :       }
    2629             :     } else {
    2630           0 :       newobj = PyObject_New(SwigPyObject, clientdata->pytype);
    2631             : #ifdef SWIGPYTHON_BUILTIN
    2632             :       newobj->dict = 0;
    2633             : #endif
    2634             :     }
    2635           0 :     if (newobj) {
    2636           0 :       newobj->ptr = ptr;
    2637           0 :       newobj->ty = type;
    2638           0 :       newobj->own = own;
    2639           0 :       newobj->next = 0;
    2640           0 :       return (PyObject*) newobj;
    2641             :     }
    2642           0 :     return SWIG_Py_Void();
    2643             :   }
    2644             : 
    2645             :   assert(!(flags & SWIG_BUILTIN_TP_INIT));
    2646             : 
    2647           1 :   robj = SwigPyObject_New(ptr, type, own);
    2648           1 :   if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    2649           1 :     PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    2650           1 :     Py_DECREF(robj);
    2651             :     robj = inst;
    2652             :   }
    2653             :   return robj;
    2654             : }
    2655             : 
    2656             : /* Create a new packed object */
    2657             : 
    2658             : SWIGRUNTIMEINLINE PyObject *
    2659             : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
    2660           0 :   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
    2661             : }
    2662             : 
    2663             : /* -----------------------------------------------------------------------------*
    2664             :  *  Get type list 
    2665             :  * -----------------------------------------------------------------------------*/
    2666             : 
    2667             : #ifdef SWIG_LINK_RUNTIME
    2668             : void *SWIG_ReturnGlobalTypeList(void *);
    2669             : #endif
    2670             : 
    2671             : SWIGRUNTIME swig_module_info *
    2672           1 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
    2673             :   static void *type_pointer = (void *)0;
    2674             :   /* first check if module already created */
    2675           1 :   if (!type_pointer) {
    2676             : #ifdef SWIG_LINK_RUNTIME
    2677             :     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
    2678             : #else
    2679             : # ifdef SWIGPY_USE_CAPSULE
    2680           1 :     type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    2681             : # else
    2682             :     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
    2683             :             (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    2684             : # endif
    2685           1 :     if (PyErr_Occurred()) {
    2686           1 :       PyErr_Clear();
    2687           1 :       type_pointer = (void *)0;
    2688             :     }
    2689             : #endif
    2690             :   }
    2691           1 :   return (swig_module_info *) type_pointer;
    2692             : }
    2693             : 
    2694             : #if PY_MAJOR_VERSION < 2
    2695             : /* PyModule_AddObject function was introduced in Python 2.0.  The following function
    2696             :    is copied out of Python/modsupport.c in python version 2.3.4 */
    2697             : SWIGINTERN int
    2698             : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
    2699             : {
    2700             :   PyObject *dict;
    2701             :   if (!PyModule_Check(m)) {
    2702             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    2703             :     return SWIG_ERROR;
    2704             :   }
    2705             :   if (!o) {
    2706             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    2707             :     return SWIG_ERROR;
    2708             :   }
    2709             :   
    2710             :   dict = PyModule_GetDict(m);
    2711             :   if (dict == NULL) {
    2712             :     /* Internal error -- modules must have a dict! */
    2713             :     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
    2714             :      PyModule_GetName(m));
    2715             :     return SWIG_ERROR;
    2716             :   }
    2717             :   if (PyDict_SetItemString(dict, name, o))
    2718             :     return SWIG_ERROR;
    2719             :   Py_DECREF(o);
    2720             :   return SWIG_OK;
    2721             : }
    2722             : #endif
    2723             : 
    2724             : SWIGRUNTIME void
    2725             : #ifdef SWIGPY_USE_CAPSULE
    2726           1 : SWIG_Python_DestroyModule(PyObject *obj)
    2727             : #else
    2728             : SWIG_Python_DestroyModule(void *vptr)
    2729             : #endif
    2730             : {
    2731             : #ifdef SWIGPY_USE_CAPSULE
    2732           1 :   swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
    2733             : #else
    2734             :   swig_module_info *swig_module = (swig_module_info *) vptr;
    2735             : #endif
    2736           1 :   swig_type_info **types = swig_module->types;
    2737             :   size_t i;
    2738           1 :   for (i =0; i < swig_module->size; ++i) {
    2739           1 :     swig_type_info *ty = types[i];
    2740           1 :     if (ty->owndata) {
    2741           1 :       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
    2742           1 :       if (data) SwigPyClientData_Del(data);
    2743             :     }
    2744             :   }
    2745           1 :   Py_DECREF(SWIG_This());
    2746           1 :   swig_this = NULL;
    2747           1 : }
    2748             : 
    2749             : SWIGRUNTIME void
    2750           1 : SWIG_Python_SetModule(swig_module_info *swig_module) {
    2751             : #if PY_VERSION_HEX >= 0x03000000
    2752             :  /* Add a dummy module object into sys.modules */
    2753           1 :   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
    2754             : #else
    2755             :   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    2756             :   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
    2757             : #endif
    2758             : #ifdef SWIGPY_USE_CAPSULE
    2759           1 :   PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
    2760           1 :   if (pointer && module) {
    2761           1 :     PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
    2762             :   } else {
    2763           0 :     Py_XDECREF(pointer);
    2764             :   }
    2765             : #else
    2766             :   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
    2767             :   if (pointer && module) {
    2768             :     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    2769             :   } else {
    2770             :     Py_XDECREF(pointer);
    2771             :   }
    2772             : #endif
    2773           1 : }
    2774             : 
    2775             : /* The python cached type query */
    2776             : SWIGRUNTIME PyObject *
    2777             : SWIG_Python_TypeCache(void) {
    2778             :   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
    2779             :   return cache;
    2780             : }
    2781             : 
    2782             : SWIGRUNTIME swig_type_info *
    2783             : SWIG_Python_TypeQuery(const char *type)
    2784             : {
    2785             :   PyObject *cache = SWIG_Python_TypeCache();
    2786             :   PyObject *key = SWIG_Python_str_FromChar(type); 
    2787             :   PyObject *obj = PyDict_GetItem(cache, key);
    2788             :   swig_type_info *descriptor;
    2789             :   if (obj) {
    2790             : #ifdef SWIGPY_USE_CAPSULE
    2791             :     descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
    2792             : #else
    2793             :     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
    2794             : #endif
    2795             :   } else {
    2796             :     swig_module_info *swig_module = SWIG_GetModule(0);
    2797             :     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    2798             :     if (descriptor) {
    2799             : #ifdef SWIGPY_USE_CAPSULE
    2800             :       obj = PyCapsule_New((void*) descriptor, NULL, NULL);
    2801             : #else
    2802             :       obj = PyCObject_FromVoidPtr(descriptor, NULL);
    2803             : #endif
    2804             :       PyDict_SetItem(cache, key, obj);
    2805             :       Py_DECREF(obj);
    2806             :     }
    2807             :   }
    2808             :   Py_DECREF(key);
    2809             :   return descriptor;
    2810             : }
    2811             : 
    2812             : /* 
    2813             :    For backward compatibility only
    2814             : */
    2815             : #define SWIG_POINTER_EXCEPTION  0
    2816             : #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
    2817             : #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
    2818             : 
    2819             : SWIGRUNTIME int
    2820             : SWIG_Python_AddErrMesg(const char* mesg, int infront)
    2821             : {  
    2822             :   if (PyErr_Occurred()) {
    2823             :     PyObject *type = 0;
    2824             :     PyObject *value = 0;
    2825             :     PyObject *traceback = 0;
    2826             :     PyErr_Fetch(&type, &value, &traceback);
    2827             :     if (value) {
    2828             :       char *tmp;
    2829             :       PyObject *old_str = PyObject_Str(value);
    2830             :       Py_XINCREF(type);
    2831             :       PyErr_Clear();
    2832             :       if (infront) {
    2833             :   PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
    2834             :       } else {
    2835             :   PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    2836             :       }
    2837             :       SWIG_Python_str_DelForPy3(tmp);
    2838             :       Py_DECREF(old_str);
    2839             :     }
    2840             :     return 1;
    2841             :   } else {
    2842             :     return 0;
    2843             :   }
    2844             : }
    2845             :   
    2846             : SWIGRUNTIME int
    2847             : SWIG_Python_ArgFail(int argnum)
    2848             : {
    2849             :   if (PyErr_Occurred()) {
    2850             :     /* add information about failing argument */
    2851             :     char mesg[256];
    2852             :     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    2853             :     return SWIG_Python_AddErrMesg(mesg, 1);
    2854             :   } else {
    2855             :     return 0;
    2856             :   }
    2857             : }
    2858             : 
    2859             : SWIGRUNTIMEINLINE const char *
    2860             : SwigPyObject_GetDesc(PyObject *self)
    2861             : {
    2862             :   SwigPyObject *v = (SwigPyObject *)self;
    2863             :   swig_type_info *ty = v ? v->ty : 0;
    2864             :   return ty ? ty->str : "";
    2865             : }
    2866             : 
    2867             : SWIGRUNTIME void
    2868             : SWIG_Python_TypeError(const char *type, PyObject *obj)
    2869             : {
    2870             :   if (type) {
    2871             : #if defined(SWIG_COBJECT_TYPES)
    2872             :     if (obj && SwigPyObject_Check(obj)) {
    2873             :       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
    2874             :       if (otype) {
    2875             :   PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
    2876             :          type, otype);
    2877             :   return;
    2878             :       }
    2879             :     } else 
    2880             : #endif      
    2881             :     {
    2882             :       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
    2883             :       if (otype) {
    2884             :   PyObject *str = PyObject_Str(obj);
    2885             :   const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
    2886             :   if (cstr) {
    2887             :     PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
    2888             :            type, otype, cstr);
    2889             :           SWIG_Python_str_DelForPy3(cstr);
    2890             :   } else {
    2891             :     PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
    2892             :            type, otype);
    2893             :   }
    2894             :   Py_XDECREF(str);
    2895             :   return;
    2896             :       }
    2897             :     }   
    2898             :     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
    2899             :   } else {
    2900             :     PyErr_Format(PyExc_TypeError, "unexpected type is received");
    2901             :   }
    2902             : }
    2903             : 
    2904             : 
    2905             : /* Convert a pointer value, signal an exception on a type mismatch */
    2906             : SWIGRUNTIME void *
    2907             : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
    2908             :   void *result;
    2909             :   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    2910             :     PyErr_Clear();
    2911             : #if SWIG_POINTER_EXCEPTION
    2912             :     if (flags) {
    2913             :       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    2914             :       SWIG_Python_ArgFail(argnum);
    2915             :     }
    2916             : #endif
    2917             :   }
    2918             :   return result;
    2919             : }
    2920             : 
    2921             : #ifdef SWIGPYTHON_BUILTIN
    2922             : SWIGRUNTIME int
    2923             : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
    2924             :   PyTypeObject *tp = obj->ob_type;
    2925             :   PyObject *descr;
    2926             :   PyObject *encoded_name;
    2927             :   descrsetfunc f;
    2928             :   int res = -1;
    2929             : 
    2930             : # ifdef Py_USING_UNICODE
    2931             :   if (PyString_Check(name)) {
    2932             :     name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    2933             :     if (!name)
    2934             :       return -1;
    2935             :   } else if (!PyUnicode_Check(name))
    2936             : # else
    2937             :   if (!PyString_Check(name))
    2938             : # endif
    2939             :   {
    2940             :     PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    2941             :     return -1;
    2942             :   } else {
    2943             :     Py_INCREF(name);
    2944             :   }
    2945             : 
    2946             :   if (!tp->tp_dict) {
    2947             :     if (PyType_Ready(tp) < 0)
    2948             :       goto done;
    2949             :   }
    2950             : 
    2951             :   descr = _PyType_Lookup(tp, name);
    2952             :   f = NULL;
    2953             :   if (descr != NULL)
    2954             :     f = descr->ob_type->tp_descr_set;
    2955             :   if (!f) {
    2956             :     if (PyString_Check(name)) {
    2957             :       encoded_name = name;
    2958             :       Py_INCREF(name);
    2959             :     } else {
    2960             :       encoded_name = PyUnicode_AsUTF8String(name);
    2961             :     }
    2962             :     PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    2963             :     Py_DECREF(encoded_name);
    2964             :   } else {
    2965             :     res = f(descr, obj, value);
    2966             :   }
    2967             :   
    2968             :   done:
    2969             :   Py_DECREF(name);
    2970             :   return res;
    2971             : }
    2972             : #endif
    2973             : 
    2974             : 
    2975             : #ifdef __cplusplus
    2976             : }
    2977             : #endif
    2978             : 
    2979             : 
    2980             : 
    2981             : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
    2982             : 
    2983             : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
    2984             : 
    2985             : 
    2986             : 
    2987             :   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 
    2988             : 
    2989             : 
    2990             : /* -------- TYPES TABLE (BEGIN) -------- */
    2991             : 
    2992             : #define SWIGTYPE_p_CompositingOperation swig_types[0]
    2993             : #define SWIGTYPE_p_DBFFieldType swig_types[1]
    2994             : #define SWIGTYPE_p_DBFInfo swig_types[2]
    2995             : #define SWIGTYPE_p__CompositingFilter swig_types[3]
    2996             : #define SWIGTYPE_p__LayerCompositer swig_types[4]
    2997             : #define SWIGTYPE_p_cgiRequestObj swig_types[5]
    2998             : #define SWIGTYPE_p_char swig_types[6]
    2999             : #define SWIGTYPE_p_classObj swig_types[7]
    3000             : #define SWIGTYPE_p_clusterObj swig_types[8]
    3001             : #define SWIGTYPE_p_colorObj swig_types[9]
    3002             : #define SWIGTYPE_p_debugLevel swig_types[10]
    3003             : #define SWIGTYPE_p_double swig_types[11]
    3004             : #define SWIGTYPE_p_errorObj swig_types[12]
    3005             : #define SWIGTYPE_p_expressionObj swig_types[13]
    3006             : #define SWIGTYPE_p_fontSetObj swig_types[14]
    3007             : #define SWIGTYPE_p_hashTableObj swig_types[15]
    3008             : #define SWIGTYPE_p_imageObj swig_types[16]
    3009             : #define SWIGTYPE_p_int swig_types[17]
    3010             : #define SWIGTYPE_p_int32_t swig_types[18]
    3011             : #define SWIGTYPE_p_intarray swig_types[19]
    3012             : #define SWIGTYPE_p_labelCacheMemberObj swig_types[20]
    3013             : #define SWIGTYPE_p_labelCacheObj swig_types[21]
    3014             : #define SWIGTYPE_p_labelCacheSlotObj swig_types[22]
    3015             : #define SWIGTYPE_p_labelLeaderObj swig_types[23]
    3016             : #define SWIGTYPE_p_labelObj swig_types[24]
    3017             : #define SWIGTYPE_p_layerObj swig_types[25]
    3018             : #define SWIGTYPE_p_legendObj swig_types[26]
    3019             : #define SWIGTYPE_p_lineObj swig_types[27]
    3020             : #define SWIGTYPE_p_mapObj swig_types[28]
    3021             : #define SWIGTYPE_p_markerCacheMemberObj swig_types[29]
    3022             : #define SWIGTYPE_p_outputFormatObj swig_types[30]
    3023             : #define SWIGTYPE_p_p_char swig_types[31]
    3024             : #define SWIGTYPE_p_p_double swig_types[32]
    3025             : #define SWIGTYPE_p_p_labelCacheMemberObj swig_types[33]
    3026             : #define SWIGTYPE_p_p_textSymbolObj swig_types[34]
    3027             : #define SWIGTYPE_p_pointObj swig_types[35]
    3028             : #define SWIGTYPE_p_projectionContext swig_types[36]
    3029             : #define SWIGTYPE_p_projectionObj swig_types[37]
    3030             : #define SWIGTYPE_p_queryMapObj swig_types[38]
    3031             : #define SWIGTYPE_p_rectObj swig_types[39]
    3032             : #define SWIGTYPE_p_referenceMapObj swig_types[40]
    3033             : #define SWIGTYPE_p_resultCacheObj swig_types[41]
    3034             : #define SWIGTYPE_p_resultObj swig_types[42]
    3035             : #define SWIGTYPE_p_scaleTokenEntryObj swig_types[43]
    3036             : #define SWIGTYPE_p_scaleTokenObj swig_types[44]
    3037             : #define SWIGTYPE_p_scalebarObj swig_types[45]
    3038             : #define SWIGTYPE_p_shapeObj swig_types[46]
    3039             : #define SWIGTYPE_p_shapefileObj swig_types[47]
    3040             : #define SWIGTYPE_p_styleObj swig_types[48]
    3041             : #define SWIGTYPE_p_symbolObj swig_types[49]
    3042             : #define SWIGTYPE_p_symbolSetObj swig_types[50]
    3043             : #define SWIGTYPE_p_uint32_t swig_types[51]
    3044             : #define SWIGTYPE_p_void swig_types[52]
    3045             : #define SWIGTYPE_p_webObj swig_types[53]
    3046             : static swig_type_info *swig_types[55];
    3047             : static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0};
    3048             : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
    3049             : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
    3050             : 
    3051             : /* -------- TYPES TABLE (END) -------- */
    3052             : 
    3053             : #if (PY_VERSION_HEX <= 0x02000000)
    3054             : # if !defined(SWIG_PYTHON_CLASSIC)
    3055             : #  error "This python version requires swig to be run with the '-classic' option"
    3056             : # endif
    3057             : #endif
    3058             : 
    3059             : /*-----------------------------------------------
    3060             :               @(target):= _mapscript.so
    3061             :   ------------------------------------------------*/
    3062             : #if PY_VERSION_HEX >= 0x03000000
    3063             : #  define SWIG_init    PyInit__mapscript
    3064             : 
    3065             : #else
    3066             : #  define SWIG_init    init_mapscript
    3067             : 
    3068             : #endif
    3069             : #define SWIG_name    "_mapscript"
    3070             : 
    3071             : #define SWIGVERSION 0x030012 
    3072             : #define SWIG_VERSION SWIGVERSION
    3073             : 
    3074             : 
    3075             : #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
    3076             : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
    3077             : 
    3078             : 
    3079             : #include "../../mapserver.h"
    3080             : #include "../../maptemplate.h"
    3081             : #include "../../mapogcsld.h"
    3082             : #include "../../mapows.h"
    3083             : #include "../../cgiutil.h"
    3084             : #include "../../mapcopy.h"
    3085             : #include "../../maperror.h"
    3086             : #include "../../mapprimitive.h"
    3087             : #include "../../mapshape.h"
    3088             : 
    3089             : #if defined(WIN32) && defined(SWIGCSHARP)
    3090             : /* <windows.h> is needed for GetExceptionCode() for unhandled exception */
    3091             : #include <windows.h>
    3092             : #endif
    3093             : 
    3094             : 
    3095             : 
    3096             : typedef int intarray;
    3097             : 
    3098             : 
    3099             : SWIGINTERN int
    3100           1 : SWIG_AsVal_double (PyObject *obj, double *val)
    3101             : {
    3102             :   int res = SWIG_TypeError;
    3103           1 :   if (PyFloat_Check(obj)) {
    3104           1 :     if (val) *val = PyFloat_AsDouble(obj);
    3105             :     return SWIG_OK;
    3106             : #if PY_VERSION_HEX < 0x03000000
    3107             :   } else if (PyInt_Check(obj)) {
    3108             :     if (val) *val = (double) PyInt_AsLong(obj);
    3109             :     return SWIG_OK;
    3110             : #endif
    3111           1 :   } else if (PyLong_Check(obj)) {
    3112           1 :     double v = PyLong_AsDouble(obj);
    3113           1 :     if (!PyErr_Occurred()) {
    3114           1 :       if (val) *val = v;
    3115             :       return SWIG_OK;
    3116             :     } else {
    3117           0 :       PyErr_Clear();
    3118             :     }
    3119             :   }
    3120             : #ifdef SWIG_PYTHON_CAST_MODE
    3121             :   {
    3122             :     int dispatch = 0;
    3123             :     double d = PyFloat_AsDouble(obj);
    3124             :     if (!PyErr_Occurred()) {
    3125             :       if (val) *val = d;
    3126             :       return SWIG_AddCast(SWIG_OK);
    3127             :     } else {
    3128             :       PyErr_Clear();
    3129             :     }
    3130             :     if (!dispatch) {
    3131             :       long v = PyLong_AsLong(obj);
    3132             :       if (!PyErr_Occurred()) {
    3133             :   if (val) *val = v;
    3134             :   return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
    3135             :       } else {
    3136             :   PyErr_Clear();
    3137             :       }
    3138             :     }
    3139             :   }
    3140             : #endif
    3141             :   return res;
    3142             : }
    3143             : 
    3144             : 
    3145             : #include <float.h>
    3146             : 
    3147             : 
    3148             : #include <math.h>
    3149             : 
    3150             : 
    3151             : SWIGINTERNINLINE int
    3152             : SWIG_CanCastAsInteger(double *d, double min, double max) {
    3153             :   double x = *d;
    3154             :   if ((min <= x && x <= max)) {
    3155             :    double fx = floor(x);
    3156             :    double cx = ceil(x);
    3157             :    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
    3158             :    if ((errno == EDOM) || (errno == ERANGE)) {
    3159             :      errno = 0;
    3160             :    } else {
    3161             :      double summ, reps, diff;
    3162             :      if (rd < x) {
    3163             :        diff = x - rd;
    3164             :      } else if (rd > x) {
    3165             :        diff = rd - x;
    3166             :      } else {
    3167             :        return 1;
    3168             :      }
    3169             :      summ = rd + x;
    3170             :      reps = diff/summ;
    3171             :      if (reps < 8*DBL_EPSILON) {
    3172             :        *d = rd;
    3173             :        return 1;
    3174             :      }
    3175             :    }
    3176             :   }
    3177             :   return 0;
    3178             : }
    3179             : 
    3180             : 
    3181             : SWIGINTERN int
    3182           0 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
    3183             : {
    3184             : #if PY_VERSION_HEX < 0x03000000
    3185             :   if (PyInt_Check(obj)) {
    3186             :     long v = PyInt_AsLong(obj);
    3187             :     if (v >= 0) {
    3188             :       if (val) *val = v;
    3189             :       return SWIG_OK;
    3190             :     } else {
    3191             :       return SWIG_OverflowError;
    3192             :     }
    3193             :   } else
    3194             : #endif
    3195           0 :   if (PyLong_Check(obj)) {
    3196           0 :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3197           0 :     if (!PyErr_Occurred()) {
    3198           0 :       if (val) *val = v;
    3199             :       return SWIG_OK;
    3200             :     } else {
    3201           0 :       PyErr_Clear();
    3202           0 :       return SWIG_OverflowError;
    3203             :     }
    3204             :   }
    3205             : #ifdef SWIG_PYTHON_CAST_MODE
    3206             :   {
    3207             :     int dispatch = 0;
    3208             :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3209             :     if (!PyErr_Occurred()) {
    3210             :       if (val) *val = v;
    3211             :       return SWIG_AddCast(SWIG_OK);
    3212             :     } else {
    3213             :       PyErr_Clear();
    3214             :     }
    3215             :     if (!dispatch) {
    3216             :       double d;
    3217             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3218             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
    3219             :   if (val) *val = (unsigned long)(d);
    3220             :   return res;
    3221             :       }
    3222             :     }
    3223             :   }
    3224             : #endif
    3225             :   return SWIG_TypeError;
    3226             : }
    3227             : 
    3228             : 
    3229             : #include <limits.h>
    3230             : #if !defined(SWIG_NO_LLONG_MAX)
    3231             : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
    3232             : #   define LLONG_MAX __LONG_LONG_MAX__
    3233             : #   define LLONG_MIN (-LLONG_MAX - 1LL)
    3234             : #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
    3235             : # endif
    3236             : #endif
    3237             : 
    3238             : 
    3239             : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
    3240             : #  define SWIG_LONG_LONG_AVAILABLE
    3241             : #endif
    3242             : 
    3243             : 
    3244             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3245             : SWIGINTERN int
    3246             : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
    3247             : {
    3248             :   int res = SWIG_TypeError;
    3249             :   if (PyLong_Check(obj)) {
    3250             :     unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    3251             :     if (!PyErr_Occurred()) {
    3252             :       if (val) *val = v;
    3253             :       return SWIG_OK;
    3254             :     } else {
    3255             :       PyErr_Clear();
    3256             :       res = SWIG_OverflowError;
    3257             :     }
    3258             :   } else {
    3259             :     unsigned long v;
    3260             :     res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    3261             :     if (SWIG_IsOK(res)) {
    3262             :       if (val) *val = v;
    3263             :       return res;
    3264             :     }
    3265             :   }
    3266             : #ifdef SWIG_PYTHON_CAST_MODE
    3267             :   {
    3268             :     const double mant_max = 1LL << DBL_MANT_DIG;
    3269             :     double d;
    3270             :     res = SWIG_AsVal_double (obj,&d);
    3271             :     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
    3272             :       return SWIG_OverflowError;
    3273             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
    3274             :       if (val) *val = (unsigned long long)(d);
    3275             :       return SWIG_AddCast(res);
    3276             :     }
    3277             :     res = SWIG_TypeError;
    3278             :   }
    3279             : #endif
    3280             :   return res;
    3281             : }
    3282             : #endif
    3283             : 
    3284             : 
    3285             : SWIGINTERNINLINE int
    3286             : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
    3287             : {
    3288             :   int res = SWIG_TypeError;
    3289             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3290             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    3291             : #endif
    3292             :     unsigned long v;
    3293           0 :     res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    3294           0 :     if (SWIG_IsOK(res) && val) *val = (size_t)(v);
    3295             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3296             :   } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    3297             :     unsigned long long v;
    3298             :     res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    3299             :     if (SWIG_IsOK(res) && val) *val = (size_t)(v);
    3300             :   }
    3301             : #endif
    3302             :   return res;
    3303             : }
    3304             : 
    3305             : SWIGINTERN intarray *new_intarray(size_t nelements){
    3306           0 :     return (int *)calloc(nelements, sizeof(int));
    3307             :   }
    3308             : SWIGINTERN void delete_intarray(intarray *self){
    3309           0 :     free((char*)self);
    3310             :   }
    3311             : SWIGINTERN int intarray___getitem__(intarray *self,size_t index){
    3312           0 :     return self[index];
    3313             :   }
    3314             : 
    3315             : SWIGINTERNINLINE PyObject*
    3316             :   SWIG_From_int  (int value)
    3317             : {
    3318           1 :   return PyInt_FromLong((long) value);
    3319             : }
    3320             : 
    3321             : 
    3322             : SWIGINTERN int
    3323           1 : SWIG_AsVal_long (PyObject *obj, long* val)
    3324             : {
    3325             : #if PY_VERSION_HEX < 0x03000000
    3326             :   if (PyInt_Check(obj)) {
    3327             :     if (val) *val = PyInt_AsLong(obj);
    3328             :     return SWIG_OK;
    3329             :   } else
    3330             : #endif
    3331           1 :   if (PyLong_Check(obj)) {
    3332           1 :     long v = PyLong_AsLong(obj);
    3333           1 :     if (!PyErr_Occurred()) {
    3334           1 :       if (val) *val = v;
    3335             :       return SWIG_OK;
    3336             :     } else {
    3337           0 :       PyErr_Clear();
    3338           0 :       return SWIG_OverflowError;
    3339             :     }
    3340             :   }
    3341             : #ifdef SWIG_PYTHON_CAST_MODE
    3342             :   {
    3343             :     int dispatch = 0;
    3344             :     long v = PyInt_AsLong(obj);
    3345             :     if (!PyErr_Occurred()) {
    3346             :       if (val) *val = v;
    3347             :       return SWIG_AddCast(SWIG_OK);
    3348             :     } else {
    3349             :       PyErr_Clear();
    3350             :     }
    3351             :     if (!dispatch) {
    3352             :       double d;
    3353             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3354             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
    3355             :   if (val) *val = (long)(d);
    3356             :   return res;
    3357             :       }
    3358             :     }
    3359             :   }
    3360             : #endif
    3361             :   return SWIG_TypeError;
    3362             : }
    3363             : 
    3364             : 
    3365             : SWIGINTERN int
    3366             : SWIG_AsVal_int (PyObject * obj, int *val)
    3367             : {
    3368             :   long v;
    3369           1 :   int res = SWIG_AsVal_long (obj, &v);
    3370           1 :   if (SWIG_IsOK(res)) {
    3371           1 :     if ((v < INT_MIN || v > INT_MAX)) {
    3372             :       return SWIG_OverflowError;
    3373             :     } else {
    3374           1 :       if (val) *val = (int)(v);
    3375             :     }
    3376             :   }  
    3377             :   return res;
    3378             : }
    3379             : 
    3380             : SWIGINTERN void intarray___setitem__(intarray *self,size_t index,int value){
    3381           0 :     self[index] = value;
    3382             :   }
    3383             : SWIGINTERN int *intarray_cast(intarray *self){
    3384             :     return self;
    3385             :   }
    3386             : SWIGINTERN intarray *intarray_frompointer(int *t){
    3387             :     return (intarray *)(t);
    3388             :   }
    3389             : 
    3390             : #ifdef __cplusplus
    3391             : extern "C" {
    3392             : #endif
    3393             : 
    3394             : typedef struct {
    3395             :     unsigned char *data;
    3396             :     int size;
    3397             :     int owns_data;
    3398             : } gdBuffer;
    3399             : 
    3400             : #ifdef __cplusplus
    3401             : }
    3402             : #endif
    3403             : 
    3404             : 
    3405             : PyObject *MSExc_MapServerError;
    3406             : PyObject *MSExc_MapServerChildError;
    3407             : 
    3408             : 
    3409             : 
    3410             : static void _raise_ms_exception( void );
    3411             : 
    3412           1 : static void _raise_ms_exception() {
    3413             :     int errcode;
    3414             :     errorObj *ms_error;
    3415             :     char *errmsg;
    3416           1 :     ms_error = msGetErrorObj();
    3417           1 :     errcode = ms_error->code;
    3418           1 :     errmsg = msGetErrorString("\n");
    3419             :     
    3420           1 :     switch (errcode) {
    3421           1 :         case MS_IOERR:
    3422           1 :             PyErr_SetString(PyExc_IOError, errmsg);
    3423           1 :             break;
    3424           0 :         case MS_MEMERR:
    3425           0 :             PyErr_SetString(PyExc_MemoryError, errmsg);
    3426           0 :             break;
    3427           0 :         case MS_TYPEERR:
    3428           0 :             PyErr_SetString(PyExc_TypeError, errmsg);
    3429           0 :             break;
    3430           0 :         case MS_EOFERR:
    3431           0 :             PyErr_SetString(PyExc_EOFError, errmsg);
    3432           0 :             break;
    3433           1 :         case MS_CHILDERR:
    3434           1 :             PyErr_SetString(MSExc_MapServerChildError, errmsg);
    3435           1 :             break;
    3436           1 :         default:
    3437           1 :             PyErr_SetString(MSExc_MapServerError, errmsg);
    3438           1 :             break;
    3439             :     }
    3440             : 
    3441           1 :     free(errmsg);
    3442           1 : }
    3443             :   
    3444             : 
    3445             : 
    3446             : SWIGINTERN swig_type_info*
    3447           1 : SWIG_pchar_descriptor(void)
    3448             : {
    3449             :   static int init = 0;
    3450             :   static swig_type_info* info = 0;
    3451           1 :   if (!init) {
    3452           1 :     info = SWIG_TypeQuery("_p_char");
    3453           1 :     init = 1;
    3454             :   }
    3455           1 :   return info;
    3456             : }
    3457             : 
    3458             : 
    3459             : SWIGINTERN int
    3460           1 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
    3461             : {
    3462             : #if PY_VERSION_HEX>=0x03000000
    3463             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3464             :   if (PyBytes_Check(obj))
    3465             : #else
    3466           1 :   if (PyUnicode_Check(obj))
    3467             : #endif
    3468             : #else  
    3469             :   if (PyString_Check(obj))
    3470             : #endif
    3471             :   {
    3472             :     char *cstr; Py_ssize_t len;
    3473             : #if PY_VERSION_HEX>=0x03000000
    3474             : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3475           1 :     if (!alloc && cptr) {
    3476             :         /* We can't allow converting without allocation, since the internal
    3477             :            representation of string in Python 3 is UCS-2/UCS-4 but we require
    3478             :            a UTF-8 representation.
    3479             :            TODO(bhy) More detailed explanation */
    3480             :         return SWIG_RuntimeError;
    3481             :     }
    3482           1 :     obj = PyUnicode_AsUTF8String(obj);
    3483           1 :     if(alloc) *alloc = SWIG_NEWOBJ;
    3484             : #endif
    3485           1 :     PyBytes_AsStringAndSize(obj, &cstr, &len);
    3486             : #else
    3487             :     PyString_AsStringAndSize(obj, &cstr, &len);
    3488             : #endif
    3489           1 :     if (cptr) {
    3490           1 :       if (alloc) {
    3491             :   /* 
    3492             :      In python the user should not be able to modify the inner
    3493             :      string representation. To warranty that, if you define
    3494             :      SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
    3495             :      buffer is always returned.
    3496             : 
    3497             :      The default behavior is just to return the pointer value,
    3498             :      so, be careful.
    3499             :   */ 
    3500             : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
    3501             :   if (*alloc != SWIG_OLDOBJ) 
    3502             : #else
    3503           1 :   if (*alloc == SWIG_NEWOBJ) 
    3504             : #endif
    3505             :   {
    3506           1 :     *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
    3507           1 :     *alloc = SWIG_NEWOBJ;
    3508             :   } else {
    3509           0 :     *cptr = cstr;
    3510           0 :     *alloc = SWIG_OLDOBJ;
    3511             :   }
    3512             :       } else {
    3513             : #if PY_VERSION_HEX>=0x03000000
    3514             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3515             :   *cptr = PyBytes_AsString(obj);
    3516             : #else
    3517             :   assert(0); /* Should never reach here with Unicode strings in Python 3 */
    3518             : #endif
    3519             : #else
    3520             :   *cptr = SWIG_Python_str_AsChar(obj);
    3521             : #endif
    3522             :       }
    3523             :     }
    3524           1 :     if (psize) *psize = len + 1;
    3525             : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3526           1 :     Py_XDECREF(obj);
    3527             : #endif
    3528             :     return SWIG_OK;
    3529             :   } else {
    3530             : #if defined(SWIG_PYTHON_2_UNICODE)
    3531             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3532             : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
    3533             : #endif
    3534             : #if PY_VERSION_HEX<0x03000000
    3535             :     if (PyUnicode_Check(obj)) {
    3536             :       char *cstr; Py_ssize_t len;
    3537             :       if (!alloc && cptr) {
    3538             :         return SWIG_RuntimeError;
    3539             :       }
    3540             :       obj = PyUnicode_AsUTF8String(obj);
    3541             :       if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
    3542             :         if (cptr) {
    3543             :           if (alloc) *alloc = SWIG_NEWOBJ;
    3544             :           *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
    3545             :         }
    3546             :         if (psize) *psize = len + 1;
    3547             : 
    3548             :         Py_XDECREF(obj);
    3549             :         return SWIG_OK;
    3550             :       } else {
    3551             :         Py_XDECREF(obj);
    3552             :       }
    3553             :     }
    3554             : #endif
    3555             : #endif
    3556             : 
    3557           1 :     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3558           1 :     if (pchar_descriptor) {
    3559           1 :       void* vptr = 0;
    3560           1 :       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
    3561           1 :   if (cptr) *cptr = (char *) vptr;
    3562           1 :   if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
    3563           1 :   if (alloc) *alloc = SWIG_OLDOBJ;
    3564           1 :   return SWIG_OK;
    3565             :       }
    3566             :     }
    3567             :   }
    3568             :   return SWIG_TypeError;
    3569             : }
    3570             : 
    3571             : 
    3572             : 
    3573             : 
    3574             : 
    3575             : SWIGINTERNINLINE PyObject *
    3576           1 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
    3577             : {
    3578           1 :   if (carray) {
    3579           1 :     if (size > INT_MAX) {
    3580           0 :       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3581             :       return pchar_descriptor ? 
    3582           0 :   SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    3583             :     } else {
    3584             : #if PY_VERSION_HEX >= 0x03000000
    3585             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3586             :       return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
    3587             : #else
    3588             : #if PY_VERSION_HEX >= 0x03010000
    3589           1 :       return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
    3590             : #else
    3591             :       return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
    3592             : #endif
    3593             : #endif
    3594             : #else
    3595             :       return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
    3596             : #endif
    3597             :     }
    3598             :   } else {
    3599           1 :     return SWIG_Py_Void();
    3600             :   }
    3601             : }
    3602             : 
    3603             : 
    3604             : SWIGINTERNINLINE PyObject * 
    3605           1 : SWIG_FromCharPtr(const char *cptr)
    3606             : { 
    3607           1 :   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
    3608             : }
    3609             : 
    3610             : 
    3611             :   #define SWIG_From_double   PyFloat_FromDouble 
    3612             : 
    3613             : SWIGINTERN int clusterObj_updateFromString(clusterObj *self,char *snippet){
    3614           1 :     return msUpdateClusterFromString(self, snippet);
    3615             :   }
    3616             : SWIGINTERN char *clusterObj_convertToString(clusterObj *self){
    3617           1 :     return msWriteClusterToString(self);
    3618             :   }
    3619           1 : SWIGINTERN int clusterObj_setGroup(clusterObj *self,char *group){
    3620           1 :     if (!group || strlen(group) == 0) {
    3621           0 :        msFreeExpression(&self->group);
    3622           0 :        return MS_SUCCESS;
    3623             :     }
    3624           1 :     else return msLoadExpressionString(&self->group, group);
    3625             :   }
    3626             : SWIGINTERN char *clusterObj_getGroupString(clusterObj *self){
    3627           1 :     return msGetExpressionString(&(self->group));
    3628             :   }
    3629           1 : SWIGINTERN int clusterObj_setFilter(clusterObj *self,char *filter){
    3630           1 :     if (!filter || strlen(filter) == 0) {
    3631           0 :       msFreeExpression(&self->filter);
    3632           0 :       return MS_SUCCESS;
    3633             :     }
    3634           1 :     else return msLoadExpressionString(&self->filter, filter);
    3635             :   }
    3636             : SWIGINTERN char *clusterObj_getFilterString(clusterObj *self){
    3637           1 :     return msGetExpressionString(&(self->filter));
    3638             :   }
    3639           1 : SWIGINTERN outputFormatObj *new_outputFormatObj(char const *driver,char *name){
    3640             :         outputFormatObj *format;
    3641             : 
    3642           1 :         format = msCreateDefaultOutputFormat(NULL, driver, name);
    3643             : 
    3644             :         /* in the case of unsupported formats, msCreateDefaultOutputFormat
    3645             :            should return NULL */
    3646           1 :         if (!format)
    3647             :         {
    3648           1 :             msSetError(12, "Unsupported format driver: %s",
    3649             :                        "outputFormatObj()", driver);
    3650           1 :             return NULL;
    3651             :         }
    3652             :         
    3653           1 :         msInitializeRendererVTable(format);
    3654             : 
    3655           1 :         MS_REFCNT_INIT(format);
    3656           1 :         format->inmapfile = 1;
    3657             : 
    3658           1 :         return format;
    3659             :     }
    3660             : SWIGINTERN void delete_outputFormatObj(outputFormatObj *self){
    3661           1 :         msFreeOutputFormat( self );
    3662             :     }
    3663             : SWIGINTERN void outputFormatObj_setExtension(outputFormatObj *self,char const *extension){
    3664           0 :         msFree( self->extension );
    3665           0 :         self->extension = msStrdup(extension);
    3666             :     }
    3667             : SWIGINTERN void outputFormatObj_setMimetype(outputFormatObj *self,char const *mimetype){
    3668           0 :         msFree( self->mimetype );
    3669           0 :         self->mimetype = msStrdup(mimetype);
    3670             :     }
    3671             : SWIGINTERN void outputFormatObj_setOption(outputFormatObj *self,char const *key,char const *value){
    3672           0 :         msSetOutputFormatOption( self, key, value );
    3673             :     }
    3674             : SWIGINTERN int outputFormatObj_validate(outputFormatObj *self){
    3675           0 :         return msOutputFormatValidate(self, 0 );
    3676             :     }
    3677             : SWIGINTERN char *outputFormatObj_getOption(outputFormatObj *self,char const *key,char const *value){
    3678           0 :         return msStrdup(msGetOutputFormatOption(self, key, value));
    3679             :     }
    3680             : SWIGINTERN char *outputFormatObj_getOptionAt(outputFormatObj *self,int i){
    3681           0 :        if( i >= 0 && i < self->numformatoptions ) {
    3682           0 :           return msStrdup(self->formatoptions[i]);
    3683             :        }
    3684             :        return NULL;
    3685             :     }
    3686             : SWIGINTERN void outputFormatObj_attachDevice(outputFormatObj *self,void *device){
    3687           0 :         self->device = device;
    3688             :     }
    3689             : SWIGINTERN int queryMapObj_updateFromString(queryMapObj *self,char *snippet){
    3690           0 :     return msUpdateQueryMapFromString(self, snippet, 0);
    3691             :   }
    3692             : SWIGINTERN char *queryMapObj_convertToString(queryMapObj *self){
    3693           0 :     return msWriteQueryMapToString(self);
    3694             :   }
    3695             : SWIGINTERN webObj *new_webObj(void){
    3696             :         webObj *web;
    3697           0 :         web = (webObj *) malloc(sizeof(webObj));
    3698           0 :         initWeb(web);
    3699             :         return web;
    3700             :     }
    3701             : SWIGINTERN void delete_webObj(webObj *self){
    3702           0 :         if (!self) return;
    3703           0 :         freeWeb(self);
    3704           0 :         free(self);
    3705             :     }
    3706             : SWIGINTERN int webObj_updateFromString(webObj *self,char *snippet){
    3707           0 :         return msUpdateWebFromString(self, snippet, 0);
    3708             :     }
    3709             : SWIGINTERN char *webObj_convertToString(webObj *self){
    3710           0 :         return msWriteWebToString(self);
    3711             :     }
    3712           1 : SWIGINTERN struct styleObj *new_styleObj(classObj *parent_class){
    3713             :     
    3714             :         styleObj *style = NULL;
    3715             :         
    3716           1 :         if (parent_class!=NULL) {
    3717           1 :             if ((style = msGrowClassStyles(parent_class)) == NULL)
    3718             :                 return NULL;
    3719             : 
    3720           1 :             if ( initStyle(style) == MS_FAILURE ) {
    3721           0 :                 msSetError(12, "Failed to init new styleObj instance",
    3722             :                                        "initStyle()");
    3723             :             }
    3724           1 :             parent_class->numstyles++;
    3725           1 :             MS_REFCNT_INCR(style);
    3726             :         }
    3727             :         else {
    3728           1 :             style = (styleObj *) malloc(sizeof(styleObj));
    3729           1 :             if (!style) { 
    3730           0 :                 msSetError(2, "Failed to allocate memory for new styleObj instance",
    3731             :                                        "styleObj()");
    3732           0 :                 return NULL;
    3733             :             }
    3734           1 :             if ( initStyle(style) == MS_FAILURE ) {
    3735           0 :                 msSetError(12, "Failed to init new styleObj instance",
    3736             :                                        "initStyle()");
    3737           0 :                 msFree(style);
    3738           0 :                 return NULL;
    3739             :             }
    3740             :         }
    3741             :         return style;
    3742             :     }
    3743           1 : SWIGINTERN void delete_styleObj(struct styleObj *self){
    3744           1 :         if (self) { 
    3745           1 :             if ( freeStyle(self) == MS_SUCCESS ) {
    3746           1 :                         free(self);
    3747             :                 self=NULL;
    3748             :             }
    3749             :         }
    3750           1 :     }
    3751             : SWIGINTERN int styleObj_updateFromString(struct styleObj *self,char *snippet){
    3752           1 :         return msUpdateStyleFromString(self, snippet, 0);
    3753             :     }
    3754             : SWIGINTERN char *styleObj_convertToString(struct styleObj *self){
    3755           1 :         return msWriteStyleToString(self);
    3756             :     }
    3757           1 : SWIGINTERN styleObj *styleObj_clone(struct styleObj *self){
    3758             :         styleObj *style;
    3759             : 
    3760           1 :         style = (styleObj *) malloc(sizeof(styleObj));
    3761           1 :         if (!style)
    3762             :         {
    3763           0 :             msSetError(2,
    3764             :                 "Could not allocate memory for new styleObj instance",
    3765             :                 "clone()");
    3766           0 :             return NULL;
    3767             :         }
    3768           1 :         if (initStyle(style) == -1)
    3769             :         {
    3770           0 :             msSetError(2, "Failed to initialize Style",
    3771             :                                   "clone()");
    3772           0 :             return NULL;
    3773             :         }
    3774             : 
    3775           1 :         if (msCopyStyle(style, self) != MS_SUCCESS)
    3776             :         {
    3777           0 :             free(style);
    3778           0 :             return NULL;
    3779             :         }
    3780             :         
    3781             :         return style;
    3782             :     }
    3783           1 : SWIGINTERN int styleObj_setSymbolByName(struct styleObj *self,mapObj *map,char *symbolname){
    3784           1 :         self->symbol = msGetSymbolIndex(&map->symbolset, symbolname, 1);
    3785           1 :         if (self->symbolname) free((char*)self->symbolname);
    3786           1 :         if (symbolname) self->symbolname = msStrdup(symbolname);
    3787           0 :         else self->symbolname = 0;
    3788           1 :         return self->symbol;
    3789             :     }
    3790             : SWIGINTERN int styleObj_removeBinding(struct styleObj *self,int binding){
    3791           0 :         if(binding < 0 || binding >= 12) return MS_FAILURE;
    3792             : 
    3793           0 :         if(self->bindings[binding].item) {
    3794           0 :             free(self->bindings[binding].item);
    3795           0 :             self->bindings[binding].item = NULL;
    3796           0 :             self->bindings[binding].index = -1;
    3797           0 :             self->numbindings--;
    3798             :         }
    3799             : 
    3800             :         return MS_SUCCESS;
    3801             :     }
    3802           1 : SWIGINTERN int styleObj_setBinding(struct styleObj *self,int binding,char *item){
    3803           1 :         if(!item) return MS_FAILURE;
    3804           1 :         if(binding < 0 || binding >= 12) return MS_FAILURE;
    3805             : 
    3806           1 :         if(self->bindings[binding].item) {
    3807           0 :             free(self->bindings[binding].item);
    3808           0 :             self->bindings[binding].item = NULL;
    3809           0 :             self->bindings[binding].index = -1;
    3810           0 :             self->numbindings--;
    3811             :         }
    3812             : 
    3813           1 :         self->bindings[binding].item = msStrdup(item);
    3814           1 :         self->numbindings++;
    3815             : 
    3816           1 :         return MS_SUCCESS;
    3817             :     }
    3818             : SWIGINTERN char *styleObj_getBinding(struct styleObj *self,int binding){
    3819           1 :         if(binding < 0 || binding >= 12) return NULL;
    3820             : 
    3821           1 :         return self->bindings[binding].item;
    3822             :     }
    3823             : SWIGINTERN char *styleObj_getGeomTransform(struct styleObj *self){
    3824             :         return self->_geomtransform.string;
    3825             :     }
    3826             : SWIGINTERN void styleObj_setGeomTransform(struct styleObj *self,char *transform){
    3827           0 :         msStyleSetGeomTransform(self, transform);
    3828             :     }
    3829           1 : SWIGINTERN void styleObj_pattern_set(struct styleObj *self,int nListSize,double *pListValues){
    3830           1 :         if( nListSize < 2 )
    3831             :         {
    3832           1 :             msSetError(4, "Not enough pattern elements. A minimum of 2 are required", "pattern_set()");
    3833           1 :             return;
    3834             :         }
    3835           1 :         if( nListSize > 10 )
    3836             :         {
    3837           1 :             msSetError(12, "Too many elements", "pattern_set()");
    3838           1 :             return;
    3839             :         }
    3840           1 :         memcpy( self->pattern, pListValues, sizeof(double) * nListSize);
    3841           1 :         self->patternlength = nListSize;
    3842             :     }
    3843             : 
    3844             : #define t_output_helper SWIG_Python_AppendOutput
    3845             : 
    3846             : 
    3847             : static PyObject *
    3848           1 : CreateTupleFromDoubleArray( double *first, unsigned int size ) {
    3849             :   unsigned int i;
    3850           1 :   PyObject *out = PyTuple_New( size );
    3851           1 :   for( i=0; i<size; i++ ) {
    3852           1 :     PyObject *val = PyFloat_FromDouble( *first );
    3853           1 :     ++first;
    3854           1 :     PyTuple_SetItem( out, i, val );
    3855             :   }
    3856           1 :   return out;
    3857             : }
    3858             : 
    3859           1 : SWIGINTERN void styleObj_pattern_get(struct styleObj *self,double **argout,int *pnListSize){
    3860           1 :         *pnListSize = self->patternlength;
    3861           1 :         *argout = (double*) malloc(sizeof(double) * *pnListSize);
    3862           1 :         memcpy( *argout, self->pattern, sizeof(double) * *pnListSize);
    3863           1 :     }
    3864             : 
    3865             : SWIGINTERN int
    3866           0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
    3867             : { 
    3868           0 :   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
    3869           0 :   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
    3870           0 :   if (SWIG_IsOK(res)) {
    3871             :     /* special case of single char conversion when we don't need space for NUL */
    3872           0 :     if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    3873           0 :     if (csize <= size) {
    3874           0 :       if (val) {
    3875           0 :   if (csize) memcpy(val, cptr, csize*sizeof(char));
    3876           0 :   if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
    3877             :       }
    3878           0 :       if (alloc == SWIG_NEWOBJ) {
    3879           0 :   free((char*)cptr);
    3880           0 :   res = SWIG_DelNewMask(res);
    3881             :       }      
    3882             :       return res;
    3883             :     }
    3884           0 :     if (alloc == SWIG_NEWOBJ) free((char*)cptr);
    3885             :   }
    3886             :   return SWIG_TypeError;
    3887             : }
    3888             : 
    3889             : 
    3890             : SWIGINTERN int
    3891           0 : SWIG_AsVal_char (PyObject * obj, char *val)
    3892             : {    
    3893           0 :   int res = SWIG_AsCharArray(obj, val, 1);
    3894           0 :   if (!SWIG_IsOK(res)) {
    3895             :     long v;
    3896           0 :     res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    3897           0 :     if (SWIG_IsOK(res)) {
    3898           0 :       if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
    3899           0 :   if (val) *val = (char)(v);
    3900             :       } else {
    3901             :   res = SWIG_OverflowError;
    3902             :       }
    3903             :     }
    3904             :   }
    3905           0 :   return res;
    3906             : }
    3907             : 
    3908             : 
    3909             : SWIGINTERNINLINE PyObject *
    3910             : SWIG_From_char  (char c) 
    3911             : { 
    3912             :   return SWIG_FromCharPtrAndSize(&c,1);
    3913             : }
    3914             : 
    3915           1 : SWIGINTERN struct labelObj *new_labelObj(void){
    3916             :       labelObj *label;
    3917             :         
    3918           1 :       label = (labelObj *)calloc(1, sizeof(labelObj));
    3919           1 :       if (!label)
    3920             :         return(NULL);
    3921             :     
    3922           1 :       initLabel(label);
    3923             :       
    3924           1 :       return(label);      
    3925             :     }
    3926             : SWIGINTERN void delete_labelObj(struct labelObj *self){
    3927           1 :       freeLabel(self);
    3928             :     }
    3929             : SWIGINTERN int labelObj_updateFromString(struct labelObj *self,char *snippet){
    3930           0 :     return msUpdateLabelFromString(self, snippet,0);
    3931             :   }
    3932             : SWIGINTERN char *labelObj_convertToString(struct labelObj *self){
    3933           0 :     return msWriteLabelToString(self);
    3934             :   }
    3935             : SWIGINTERN int labelObj_removeBinding(struct labelObj *self,int binding){
    3936           0 :     if(binding < 0 || binding >= 12) return MS_FAILURE;
    3937             : 
    3938           0 :     if(self->bindings[binding].item) {
    3939           0 :       free(self->bindings[binding].item);
    3940           0 :       self->bindings[binding].item = NULL;
    3941           0 :       self->bindings[binding].index = -1; 
    3942           0 :       self->numbindings--;
    3943             :     }
    3944             : 
    3945             :     return MS_SUCCESS;
    3946             :   }
    3947             : SWIGINTERN char *labelObj_getBinding(struct labelObj *self,int binding){
    3948           1 :     if(binding < 0 || binding >= 12) return NULL;
    3949             : 
    3950           1 :     return self->bindings[binding].item;
    3951             :   }
    3952           1 : SWIGINTERN int labelObj_setBinding(struct labelObj *self,int binding,char *item){
    3953           1 :     if(!item) return MS_FAILURE;
    3954           1 :     if(binding < 0 || binding >= 12) return MS_FAILURE;
    3955             : 
    3956           1 :     if(self->bindings[binding].item) {
    3957           0 :       free(self->bindings[binding].item);
    3958           0 :       self->bindings[binding].item = NULL; 
    3959           0 :       self->bindings[binding].index = -1;
    3960           0 :       self->numbindings--;
    3961             :     }
    3962             : 
    3963           1 :     self->bindings[binding].item = msStrdup(item); 
    3964           1 :     self->numbindings++;
    3965             : 
    3966           1 :     return MS_SUCCESS;
    3967             :   }
    3968           0 : SWIGINTERN int labelObj_setExpression(struct labelObj *self,char *expression){
    3969           0 :     if (!expression || strlen(expression) == 0) {
    3970           0 :        msFreeExpression(&self->expression);
    3971           0 :        return MS_SUCCESS;
    3972             :     }
    3973           0 :     else return msLoadExpressionString(&self->expression, expression);
    3974             :   }
    3975             : SWIGINTERN char *labelObj_getExpressionString(struct labelObj *self){
    3976           0 :     return msGetExpressionString(&(self->expression));
    3977             :   }
    3978           0 : SWIGINTERN int labelObj_setText(struct labelObj *self,char *text){
    3979           0 :     if (!text || strlen(text) == 0) {
    3980           0 :       msFreeExpression(&self->text);
    3981           0 :       return MS_SUCCESS;
    3982             :     } 
    3983           0 :     else return msLoadExpressionString(&self->text, text);
    3984             :   }
    3985             : SWIGINTERN char *labelObj_getTextString(struct labelObj *self){
    3986           0 :     return msGetExpressionString(&(self->text));
    3987             :   }
    3988           0 : SWIGINTERN styleObj *labelObj_getStyle(struct labelObj *self,int i){
    3989           0 :       if (i >= 0 && i < self->numstyles) {
    3990           0 :           MS_REFCNT_INCR(self->styles[i]);
    3991           0 :           return self->styles[i];
    3992             :       } else {
    3993           0 :           msSetError(31, "Invalid index: %d", "getStyle()", i);
    3994             :           return NULL;
    3995             :       }
    3996             :   }
    3997             : SWIGINTERN int labelObj_insertStyle(struct labelObj *self,styleObj *style,int index){
    3998           0 :         return msInsertLabelStyle(self, style, index);
    3999             :     }
    4000           0 : SWIGINTERN styleObj *labelObj_removeStyle(struct labelObj *self,int index){
    4001           0 :         styleObj* style = (styleObj *) msRemoveLabelStyle(self, index);
    4002           0 :         if (style)
    4003           0 :             MS_REFCNT_INCR(style);
    4004           0 :             return style;
    4005             :     }
    4006             : SWIGINTERN int labelObj_moveStyleUp(struct labelObj *self,int index){
    4007           0 :         return msMoveLabelStyleUp(self, index);
    4008             :     }
    4009             : SWIGINTERN int labelObj_moveStyleDown(struct labelObj *self,int index){
    4010           0 :        return msMoveLabelStyleDown(self, index);
    4011             :     }
    4012           1 : SWIGINTERN struct classObj *new_classObj(layerObj *layer){
    4013             :         classObj *new_class=NULL;
    4014             :         
    4015           1 :         if (!layer)
    4016             :         {
    4017           1 :             new_class = (classObj *) malloc(sizeof(classObj));
    4018           1 :             if (!new_class)
    4019             :             {
    4020           0 :                 msSetError(2,
    4021             :                     "Could not allocate memory for new classObj instance",
    4022             :                     "classObj()");
    4023           0 :                 return NULL;
    4024             :             }
    4025           1 :             if (initClass(new_class) == -1) return NULL;
    4026           1 :             new_class->layer = NULL;
    4027           1 :             return new_class;
    4028             :         }
    4029             :         else
    4030             :         {
    4031           1 :             if(msGrowLayerClasses(layer) == NULL)
    4032             :                 return NULL;
    4033           1 :             if (initClass(layer->class[layer->numclasses]) == -1)
    4034             :                 return NULL;
    4035           1 :             layer->class[layer->numclasses]->layer = layer;
    4036           1 :             MS_REFCNT_INCR(layer->class[layer->numclasses]);
    4037           1 :             layer->numclasses++;
    4038           1 :             return (layer->class[layer->numclasses-1]);
    4039             :         }
    4040             : 
    4041             :         return NULL;
    4042             :     }
    4043           1 : SWIGINTERN void delete_classObj(struct classObj *self){
    4044           1 :         if (self)
    4045             :         {
    4046           1 :             if (freeClass(self)==MS_SUCCESS) {
    4047           1 :                 free(self);
    4048             :                 self=NULL;
    4049             :             }
    4050             :         }
    4051           1 :     }
    4052             : SWIGINTERN int classObj_updateFromString(struct classObj *self,char *snippet){
    4053           0 :         return msUpdateClassFromString(self, snippet, 0);
    4054             :     }
    4055             : SWIGINTERN char *classObj_convertToString(struct classObj *self){
    4056           0 :         return msWriteClassToString(self);
    4057             :     }
    4058           1 : SWIGINTERN classObj *classObj_clone(struct classObj *self){
    4059             :         classObj *new_class;
    4060             : 
    4061           1 :         new_class = (classObj *) malloc(sizeof(classObj));
    4062           1 :         if (!new_class)
    4063             :         {
    4064           0 :             msSetError(2,
    4065             :                 "Could not allocate memory for new classObj instance",
    4066             :                 "clone()");
    4067           0 :             return NULL;
    4068             :         }
    4069           1 :         if (initClass(new_class) == -1)
    4070             :         {
    4071           0 :             msSetError(2, "Failed to initialize Class",
    4072             :                                   "clone()");
    4073           0 :             return NULL;
    4074             :         }
    4075           1 :         new_class->layer = NULL;
    4076             : 
    4077           1 :         if (msCopyClass(new_class, self, self->layer) != MS_SUCCESS) {
    4078           0 :             freeClass(new_class);
    4079           0 :             free(new_class);
    4080             :             new_class = NULL;
    4081             :         }
    4082             :         
    4083             :         return new_class;
    4084             :     }
    4085           0 : SWIGINTERN int classObj_setExpression(struct classObj *self,char *expression){
    4086           0 :     if (!expression || strlen(expression) == 0) {
    4087           0 :        msFreeExpression(&self->expression);
    4088           0 :        return MS_SUCCESS;
    4089             :     }
    4090           0 :     else return msLoadExpressionString(&self->expression, expression);
    4091             :   }
    4092             : SWIGINTERN char *classObj_getExpressionString(struct classObj *self){
    4093           0 :     return msGetExpressionString(&(self->expression));
    4094             :   }
    4095           0 : SWIGINTERN int classObj_setText(struct classObj *self,char *text){
    4096           0 :     if (!text || strlen(text) == 0) {
    4097           0 :       msFreeExpression(&self->text);
    4098           0 :       return MS_SUCCESS;
    4099             :     }    
    4100           0 :     else return msLoadExpressionString(&self->text, text);
    4101             :   }
    4102             : SWIGINTERN char *classObj_getTextString(struct classObj *self){
    4103           0 :     return msGetExpressionString(&(self->text));
    4104             :   }
    4105           0 : SWIGINTERN char *classObj_getMetaData(struct classObj *self,char *name){
    4106             :     char *value = NULL;
    4107           0 :     if (!name) {
    4108           0 :       msSetError(16, "NULL key", "getMetaData");
    4109             :     }
    4110             :      
    4111           0 :     value = (char *) msLookupHashTable(&(self->metadata), name);
    4112           0 :     if (!value) {
    4113           0 :       msSetError(16, "Key %s does not exist", "getMetaData", name);
    4114           0 :       return NULL;
    4115             :     }
    4116             :     return value;
    4117             :   }
    4118             : SWIGINTERN int classObj_setMetaData(struct classObj *self,char *name,char *value){
    4119           0 :     if (msInsertHashTable(&(self->metadata), name, value) == NULL)
    4120             :         return MS_FAILURE;
    4121             :     return MS_SUCCESS;
    4122             :   }
    4123             : SWIGINTERN char *classObj_getFirstMetaDataKey(struct classObj *self){
    4124           1 :     return (char *) msFirstKeyFromHashTable(&(self->metadata));
    4125             :   }
    4126             : SWIGINTERN char *classObj_getNextMetaDataKey(struct classObj *self,char *lastkey){
    4127           1 :     return (char *) msNextKeyFromHashTable(&(self->metadata), lastkey);
    4128             :   }
    4129           0 : SWIGINTERN int classObj_drawLegendIcon(struct classObj *self,mapObj *map,layerObj *layer,int width,int height,imageObj *dstImage,int dstX,int dstY){    
    4130           0 :     if(layer->sizeunits != MS_PIXELS) {
    4131           0 :       map->cellsize = msAdjustExtent(&(map->extent), map->width, map->height);
    4132           0 :       layer->scalefactor = (msInchesPerUnit(layer->sizeunits,0)/msInchesPerUnit(map->units,0)) / map->cellsize;
    4133             :     }
    4134             :     else
    4135           0 :       layer->scalefactor = map->resolution/map->defresolution;
    4136             :     
    4137           0 :     return msDrawLegendIcon(map, layer, self, width, height, dstImage, dstX, dstY, 1, NULL);
    4138             :   }
    4139             : SWIGINTERN imageObj *classObj_createLegendIcon(struct classObj *self,mapObj *map,layerObj *layer,int width,int height){
    4140           1 :     return msCreateLegendIcon(map, layer, self, width, height, 1);
    4141             :   }
    4142           1 : SWIGINTERN labelObj *classObj_getLabel(struct classObj *self,int i){
    4143           1 :     if (i >= 0 && i < self->numlabels) {
    4144           1 :       MS_REFCNT_INCR(self->labels[i]);
    4145           1 :       return self->labels[i];
    4146             :     } else {
    4147           0 :       msSetError(31, "Invalid index: %d.", "getLabel()", i);
    4148             :       return NULL;
    4149             :     }
    4150             :   }
    4151             : SWIGINTERN int classObj_addLabel(struct classObj *self,labelObj *label){
    4152           1 :     return msAddLabelToClass(self, label);
    4153             :   }
    4154           0 : SWIGINTERN labelObj *classObj_removeLabel(struct classObj *self,int index){
    4155           0 :     labelObj* label = (labelObj *) msRemoveLabelFromClass(self, index);
    4156           0 :     if (label) MS_REFCNT_INCR(label);
    4157           0 :     return label;
    4158             :   }
    4159           1 : SWIGINTERN styleObj *classObj_getStyle(struct classObj *self,int i){
    4160           1 :     if (i >= 0 && i < self->numstyles) {
    4161           1 :       MS_REFCNT_INCR(self->styles[i]);
    4162           1 :       return self->styles[i];
    4163             :     } else {
    4164           0 :       msSetError(31, "Invalid index: %d", "getStyle()", i);
    4165             :       return NULL;
    4166             :     }
    4167             :   }
    4168             : SWIGINTERN int classObj_insertStyle(struct classObj *self,styleObj *style,int index){
    4169           1 :     return msInsertStyle(self, style, index);
    4170             :   }
    4171           1 : SWIGINTERN styleObj *classObj_removeStyle(struct classObj *self,int index){
    4172           1 :     styleObj* style = (styleObj *) msRemoveStyle(self, index);
    4173           1 :     if (style) MS_REFCNT_INCR(style);
    4174           1 :     return style;
    4175             :   }
    4176             : SWIGINTERN int classObj_moveStyleUp(struct classObj *self,int index){
    4177           0 :     return msMoveStyleUp(self, index);
    4178             :   }
    4179             : SWIGINTERN int classObj_moveStyleDown(struct classObj *self,int index){
    4180           0 :     return msMoveStyleDown(self, index);
    4181             :   }
    4182             : SWIGINTERN void labelCacheObj_freeCache(labelCacheObj *self){
    4183           0 :         msFreeLabelCache(self);
    4184             :     }
    4185             : 
    4186             :   #define SWIG_From_long   PyInt_FromLong 
    4187             : 
    4188             : SWIGINTERN resultObj *new_resultObj(long shapeindex){
    4189           0 :         resultObj *result = (resultObj *) msSmallMalloc(sizeof(resultObj));
    4190             : 
    4191           0 :         result->tileindex = -1;
    4192           0 :         result->resultindex = -1; 
    4193           0 :         result->shapeindex = shapeindex;
    4194             :         
    4195             :         return result;
    4196             :     }
    4197             : SWIGINTERN void delete_resultObj(resultObj *self){
    4198           0 :         free(self);
    4199             :     }
    4200             : SWIGINTERN resultObj *resultCacheObj_getResult(resultCacheObj *self,int i){
    4201           1 :         if (i >= 0 && i < self->numresults) {
    4202           1 :             return &self->results[i];
    4203             :         }
    4204             :         return NULL;
    4205             :     }
    4206           1 : SWIGINTERN symbolSetObj *new_symbolSetObj(char const *symbolfile){
    4207             :         symbolSetObj *symbolset;
    4208             :         mapObj *temp_map=NULL;
    4209           1 :         symbolset = (symbolSetObj *) malloc(sizeof(symbolSetObj));
    4210           1 :         msInitSymbolSet(symbolset);
    4211           1 :         if (symbolfile) {
    4212           1 :             symbolset->filename = msStrdup(symbolfile);
    4213           1 :             temp_map = msNewMapObj();
    4214           1 :             msLoadSymbolSet(symbolset, temp_map);
    4215           1 :             symbolset->map = NULL;
    4216           1 :             msFreeMap(temp_map);
    4217             :         }
    4218           1 :         return symbolset;
    4219             :     }
    4220           1 : SWIGINTERN void delete_symbolSetObj(symbolSetObj *self){
    4221           1 :         msFreeSymbolSet(self);
    4222           1 :         if (self->filename) free(self->filename);
    4223           1 :         free(self);
    4224           1 :     }
    4225             : SWIGINTERN symbolObj *symbolSetObj_getSymbol(symbolSetObj *self,int i){
    4226           1 :         if (i >= 0 && i < self->numsymbols) {
    4227           1 :             symbolObj *s=self->symbol[i];
    4228           1 :             MS_REFCNT_INCR(s);
    4229             :             return s;
    4230             :         } else
    4231             :             return NULL;
    4232             :     }
    4233           1 : SWIGINTERN symbolObj *symbolSetObj_getSymbolByName(symbolSetObj *self,char *symbolname){
    4234             :         int i;
    4235             : 
    4236           1 :         if (!symbolname) return NULL;
    4237             : 
    4238           1 :         i = msGetSymbolIndex(self, symbolname, 1);
    4239           1 :         if (i == -1)
    4240             :             return NULL;
    4241             :         else {
    4242           1 :             MS_REFCNT_INCR(self->symbol[i]);
    4243           1 :             return self->symbol[i];
    4244             :         }
    4245             :     }
    4246             : SWIGINTERN int symbolSetObj_index(symbolSetObj *self,char *symbolname){
    4247           1 :         return msGetSymbolIndex(self, symbolname, 1);
    4248             :     }
    4249             : SWIGINTERN int symbolSetObj_appendSymbol(symbolSetObj *self,symbolObj *symbol){
    4250           1 :         return msAppendSymbol(self, symbol);
    4251             :     }
    4252           1 : SWIGINTERN symbolObj *symbolSetObj_removeSymbol(symbolSetObj *self,int index){
    4253           1 :         symbolObj *s=msRemoveSymbol(self, index);
    4254           1 :         if (s!=NULL) {
    4255           1 :             MS_REFCNT_INCR(s);
    4256             :         }
    4257           1 :         return s;
    4258             :     }
    4259             : SWIGINTERN int symbolSetObj_save(symbolSetObj *self,char const *filename){
    4260           1 :         return msSaveSymbolSet(self, filename);
    4261             :     }
    4262             : SWIGINTERN int referenceMapObj_updateFromString(referenceMapObj *self,char *snippet){
    4263           0 :     return msUpdateReferenceMapFromString(self, snippet, 0);
    4264             :   }
    4265             : SWIGINTERN char *referenceMapObj_convertToString(referenceMapObj *self){
    4266           0 :     return msWriteReferenceMapToString(self);
    4267             :   }
    4268             : SWIGINTERN int scalebarObj_updateFromString(scalebarObj *self,char *snippet){
    4269           0 :     return msUpdateScalebarFromString(self, snippet, 0);
    4270             :   }
    4271             : SWIGINTERN char *scalebarObj_convertToString(scalebarObj *self){
    4272           0 :     return msWriteScalebarToString(self);
    4273             :   }
    4274             : SWIGINTERN int legendObj_updateFromString(legendObj *self,char *snippet){
    4275           0 :     return msUpdateLegendFromString(self, snippet, 0);
    4276             :   }
    4277             : SWIGINTERN char *legendObj_convertToString(legendObj *self){
    4278           0 :     return msWriteLegendToString(self);
    4279             :   }
    4280           1 : SWIGINTERN struct imageObj *new_imageObj(int width,int height,outputFormatObj *input_format,char const *file,double resolution,double defresolution){
    4281             :         imageObj *image=NULL;
    4282             :         outputFormatObj *format;
    4283             :         rendererVTableObj *renderer = NULL;
    4284             :         rasterBufferObj *rb = NULL;
    4285             : 
    4286           1 :         if (input_format) {
    4287             :             format = input_format;
    4288             :         }
    4289             :         else {
    4290           1 :             format = msCreateDefaultOutputFormat(NULL, "AGG/PNG", "aggpng");
    4291           1 :             if (format)
    4292           1 :                 msInitializeRendererVTable(format);
    4293             :         }
    4294           1 :         if (format == NULL) {
    4295           0 :             msSetError(15, "Could not create output format",
    4296             :                        "imageObj()");
    4297           0 :             return NULL;
    4298             :         }
    4299             : 
    4300           1 :         if (file) {
    4301             : 
    4302           0 :             renderer = format->vtable;
    4303           0 :             rb = (rasterBufferObj*) malloc(sizeof(rasterBufferObj));
    4304           0 :             if (!rb) {
    4305           0 :                 msSetError(2, NULL, "imageObj()");
    4306           0 :                 return NULL;
    4307             :             }
    4308           0 :             if ( (renderer->loadImageFromFile((char *)file, rb)) == MS_FAILURE) {
    4309           0 :                 msFreeRasterBuffer(rb);
    4310           0 :                 free(rb);
    4311           0 :                 return NULL;
    4312             :             }
    4313           0 :             image = msImageCreate(rb->width, rb->height, format, NULL, NULL,
    4314             :                                   resolution, defresolution, NULL);
    4315           0 :             if (! image) {
    4316           0 :                 msFreeRasterBuffer(rb);
    4317           0 :                 free(rb);
    4318           0 :                 return NULL;
    4319             :             }
    4320             : 
    4321           0 :             if(renderer->mergeRasterBuffer(image, rb, 1.0, 0, 0, 0, 0, rb->width, rb->height) != MS_SUCCESS) {
    4322           0 :                 msFreeImage(image);
    4323             :                 image = NULL;
    4324             :             }
    4325             : 
    4326           0 :             msFreeRasterBuffer(rb);
    4327           0 :             free(rb);
    4328             : 
    4329           0 :             return image;
    4330             :         }
    4331             : 
    4332           1 :         image = msImageCreate(width, height, format, NULL, NULL, resolution, defresolution, NULL);
    4333           1 :         return image;
    4334             :     }
    4335             : SWIGINTERN void delete_imageObj(struct imageObj *self){
    4336           1 :         msFreeImage(self);
    4337             :     }
    4338             : SWIGINTERN void imageObj_save(struct imageObj *self,char *filename,mapObj *map){
    4339           1 :         msSaveImage(map, self, filename );
    4340             :     }
    4341           1 : SWIGINTERN gdBuffer imageObj_getBytes(struct imageObj *self){
    4342             :         gdBuffer buffer;
    4343             : 
    4344           1 :         buffer.owns_data = 1;
    4345             : 
    4346           1 :         buffer.data = msSaveImageBuffer(self, &buffer.size, self->format);
    4347             : 
    4348           1 :         if( buffer.data == NULL || buffer.size == 0 )
    4349             :         {
    4350           0 :             buffer.data = NULL;
    4351           0 :             msSetError(12, "Failed to get image buffer", "getBytes");
    4352           0 :             return buffer;
    4353             :         }
    4354             : 
    4355           1 :         return buffer;
    4356             :     }
    4357           0 : SWIGINTERN int imageObj_getSize(struct imageObj *self){
    4358             :         gdBuffer buffer;
    4359             :         int size=0;
    4360             : 
    4361           0 :         buffer.data = msSaveImageBuffer(self, &buffer.size, self->format);
    4362           0 :         size = buffer.size;
    4363             : 
    4364           0 :         if( buffer.data == NULL || buffer.size == 0 ) {
    4365           0 :             buffer.data = NULL;
    4366           0 :             msSetError(12, "Failed to get image buffer size", "getSize");
    4367             :         }
    4368           0 :         free(buffer.data);
    4369           0 :         return size;
    4370             :     }
    4371           1 : SWIGINTERN int imageObj_write(struct imageObj *self,PyObject *file){
    4372             :         unsigned char *imgbuffer=NULL;
    4373             :         int imgsize;
    4374             :         PyObject *noerr;
    4375             :         int retval=MS_FAILURE;
    4376             : 
    4377             :         /* Return immediately if image driver is not GD */
    4378           1 :         if ( !MS_RENDERER_PLUGIN(self->format) )
    4379             :         {
    4380           0 :             msSetError(15, "Writing of %s format not implemented",
    4381             :                        "imageObj::write", self->format->driver);
    4382           0 :             return MS_FAILURE;
    4383             :         }
    4384             : 
    4385           1 :         if (file == Py_None) /* write to stdout */
    4386           0 :             retval = msSaveImage(NULL, self, NULL);
    4387             :         else /* presume a Python file-like object */
    4388             :         {
    4389           1 :             imgbuffer = msSaveImageBuffer(self, &imgsize,
    4390             :                                           self->format);
    4391           1 :             if (imgsize == 0)
    4392             :             {
    4393           0 :                 msSetError(15, "failed to get image buffer", "write()");
    4394           0 :                 return MS_FAILURE;
    4395             :             }
    4396             : 
    4397             : #if PY_MAJOR_VERSION >= 3
    4398             :             // https://docs.python.org/3/c-api/arg.html
    4399           1 :             noerr = PyObject_CallMethod(file, "write", "y#", imgbuffer, imgsize);
    4400             : #else
    4401             :             // https://docs.python.org/2/c-api/arg.html
    4402             :             noerr = PyObject_CallMethod(file, "write", "s#", imgbuffer, imgsize);
    4403             : #endif
    4404             : 
    4405           1 :             free(imgbuffer);
    4406           1 :             if (noerr == NULL)
    4407             :                 return MS_FAILURE;
    4408             :             else
    4409           1 :                 Py_DECREF(noerr);
    4410             :             retval = MS_SUCCESS;
    4411             :         }
    4412             : 
    4413             :         return retval;
    4414             :     }
    4415           1 : SWIGINTERN PyObject *imageObj_saveToString(struct imageObj *self){
    4416           1 :         int size=0;
    4417             :         unsigned char *imgbytes;
    4418             :         PyObject *imgstring; 
    4419             : 
    4420           1 :         imgbytes = msSaveImageBuffer(self, &size, self->format);
    4421           1 :         if (size == 0)
    4422             :         {
    4423           0 :             msSetError(15, "failed to get image buffer", "saveToString()");
    4424           0 :             return NULL;
    4425             :         }
    4426           1 :         imgstring = PyBytes_FromStringAndSize((const char*) imgbytes, size);
    4427           1 :         free(imgbytes);
    4428           1 :         return imgstring;
    4429             :     }
    4430           1 : SWIGINTERN struct layerObj *new_layerObj(mapObj *map){
    4431             :         layerObj *layer;
    4432             :         int result;
    4433             :         
    4434           1 :         if (!map) {
    4435           1 :             layer = (layerObj *) malloc(sizeof(layerObj));
    4436           1 :             if (!layer) {
    4437           0 :                 msSetError(2, "Failed to initialize Layer",
    4438             :                                        "layerObj()");
    4439           0 :                 return NULL;
    4440             :             } 
    4441           1 :             result = initLayer(layer, NULL);
    4442           1 :             if (result == MS_SUCCESS) {
    4443           1 :                 layer->index = -1;
    4444           1 :                 return layer;
    4445             :             }
    4446             :             else {
    4447           0 :                 msSetError(2, "Failed to initialize Layer",
    4448             :                                        "layerObj()");
    4449           0 :                 return NULL;
    4450             :             }
    4451             :         }
    4452             :         else {
    4453           1 :             if(msGrowMapLayers(map) == NULL)
    4454             :                 return(NULL);
    4455             : 
    4456           1 :             if (initLayer((map->layers[map->numlayers]), map) == -1)
    4457             :                 return(NULL);
    4458             : 
    4459           1 :             map->layers[map->numlayers]->index = map->numlayers;
    4460           1 :             map->layerorder[map->numlayers] = map->numlayers;
    4461           1 :             map->numlayers++;
    4462           1 :         MS_REFCNT_INCR(map->layers[map->numlayers-1]);
    4463             : 
    4464           1 :             return (map->layers[map->numlayers-1]);
    4465             :         }
    4466             :     }
    4467             : SWIGINTERN void layerObj_setOpacity(struct layerObj *self,int opacity){
    4468           0 :       msSetLayerOpacity(self, opacity);
    4469             :     }
    4470             : SWIGINTERN int layerObj_getOpacity(struct layerObj *self){
    4471           0 :       if(self->compositer) return (self->compositer->opacity);
    4472             :       return (100);
    4473             :     }
    4474           1 : SWIGINTERN void delete_layerObj(struct layerObj *self){
    4475             :         /*if (!self->map) {*/
    4476           1 :         if (self) {
    4477           1 :             if(freeLayer(self)==MS_SUCCESS) {
    4478           1 :                 free(self);
    4479             :         }
    4480             :         }
    4481           1 :     }
    4482           1 : SWIGINTERN layerObj *layerObj_clone(struct layerObj *self){
    4483             :         layerObj *layer;
    4484             :         int result;
    4485             : 
    4486           1 :         layer = (layerObj *) malloc(sizeof(layerObj));
    4487           1 :         if (!layer) {
    4488           0 :             msSetError(2, "Failed to initialize Layer",
    4489             :                                   "layerObj()");
    4490           0 :             return NULL;
    4491             :         } 
    4492           1 :         result = initLayer(layer, NULL);
    4493           1 :         if (result != MS_SUCCESS) {
    4494           0 :             msSetError(2, "Failed to initialize Layer",
    4495             :                                   "layerObj()");
    4496           0 :             return NULL;
    4497             :         }
    4498             : 
    4499           1 :         if (msCopyLayer(layer, self) != MS_SUCCESS) {
    4500           0 :             freeLayer(layer);
    4501           0 :             free(layer);
    4502             :             layer = NULL;
    4503             :         }
    4504           1 :         layer->map = NULL;
    4505           1 :         layer->index = -1;
    4506             :         
    4507           1 :         return layer;
    4508             :     }
    4509             : SWIGINTERN int layerObj_updateFromString(struct layerObj *self,char *snippet){
    4510           1 :         return msUpdateLayerFromString(self, snippet, 0);
    4511             :     }
    4512             : SWIGINTERN char *layerObj_convertToString(struct layerObj *self){
    4513           0 :         return msWriteLayerToString(self);
    4514             :     }
    4515             : SWIGINTERN int layerObj_insertClass(struct layerObj *self,classObj *classobj,int index){
    4516           1 :         return msInsertClass(self, classobj, index);
    4517             :     }
    4518           1 : SWIGINTERN classObj *layerObj_removeClass(struct layerObj *self,int index){
    4519           1 :         classObj* c = msRemoveClass(self, index);
    4520           1 :     if (c != NULL) {
    4521           1 :         MS_REFCNT_INCR(c);
    4522             :     }
    4523           1 :     return c;
    4524             :     }
    4525           1 : SWIGINTERN int layerObj_open(struct layerObj *self){
    4526             :         int status;
    4527           1 :         status =  msLayerOpen(self);
    4528           1 :         if (status == MS_SUCCESS) {
    4529           1 :             return msLayerGetItems(self);
    4530             :         }
    4531             :         return status;
    4532             :     }
    4533           0 : SWIGINTERN int layerObj_whichShapes(struct layerObj *self,rectObj rect){
    4534           0 :         int oldconnectiontype = self->connectiontype;
    4535           0 :         self->connectiontype = MS_INLINE;
    4536             : 
    4537           0 :         if(msLayerWhichItems(self, 1, NULL) != MS_SUCCESS) {
    4538           0 :             self->connectiontype = oldconnectiontype;
    4539           0 :             return MS_FAILURE;
    4540             :         }
    4541           0 :         self->connectiontype = oldconnectiontype;
    4542             : 
    4543           0 :         return msLayerWhichShapes(self, rect, 0);
    4544             :     }
    4545           0 : SWIGINTERN shapeObj *layerObj_nextShape(struct layerObj *self){
    4546             :        int status;
    4547             :        shapeObj *shape;
    4548             : 
    4549           0 :        shape = (shapeObj *)malloc(sizeof(shapeObj));
    4550           0 :        if (!shape) return NULL;
    4551           0 :        msInitShape(shape);
    4552             : 
    4553           0 :        status = msLayerNextShape(self, shape);
    4554           0 :        if(status != MS_SUCCESS) {
    4555           0 :          msFreeShape(shape);
    4556           0 :      free(shape);
    4557           0 :      return NULL;
    4558             :        } else
    4559             :          return shape;
    4560             :     }
    4561             : SWIGINTERN void layerObj_close(struct layerObj *self){
    4562           1 :         msLayerClose(self);
    4563             :     }
    4564           1 : SWIGINTERN shapeObj *layerObj_getShape(struct layerObj *self,resultObj *record){
    4565             :         int retval;
    4566             :         shapeObj *shape;
    4567             : 
    4568           1 :         if (!record) return NULL;
    4569             :     
    4570           1 :         shape = (shapeObj *)malloc(sizeof(shapeObj));
    4571           1 :         if (!shape) return NULL;
    4572             : 
    4573           1 :         msInitShape(shape);
    4574           1 :         shape->type = self->type; /* is this right? */
    4575             : 
    4576           1 :         retval = msLayerGetShape(self, shape, record);
    4577           1 :         if(retval != MS_SUCCESS) {
    4578           0 :           msFreeShape(shape);
    4579           0 :           free(shape);
    4580           0 :           return NULL;
    4581             :         } else
    4582             :         return shape;
    4583             :     }
    4584             : SWIGINTERN int layerObj_getNumResults(struct layerObj *self){
    4585           1 :         if (!self->resultcache) return 0;
    4586           1 :         return self->resultcache->numresults;
    4587             :     }
    4588           0 : SWIGINTERN rectObj *layerObj_getResultsBounds(struct layerObj *self){
    4589             :         rectObj *bounds;
    4590           0 :         if (!self->resultcache) return NULL;
    4591           0 :         bounds = (rectObj *) malloc(sizeof(rectObj));
    4592           0 :         MS_COPYRECT(bounds, &self->resultcache->bounds);
    4593             :         return bounds;
    4594             :     }
    4595             : SWIGINTERN resultObj *layerObj_getResult(struct layerObj *self,int i){
    4596           1 :         if (!self->resultcache) return NULL;
    4597           1 :         if (i >= 0 && i < self->resultcache->numresults)
    4598           1 :             return &self->resultcache->results[i]; 
    4599             :         else
    4600             :             return NULL;
    4601             :     }
    4602             : SWIGINTERN classObj *layerObj_getClass(struct layerObj *self,int i){
    4603             :     classObj *result=NULL;
    4604           1 :         if (i >= 0 && i < self->numclasses) {
    4605           1 :             result=self->class[i]; 
    4606           1 :         MS_REFCNT_INCR(result);
    4607             :     }
    4608             :     return result;
    4609             :     }
    4610             : SWIGINTERN char *layerObj_getItem(struct layerObj *self,int i){
    4611             :   
    4612           1 :         if (i >= 0 && i < self->numitems)
    4613           1 :             return (char *) (self->items[i]);
    4614             :         else
    4615             :             return NULL;
    4616             :     }
    4617             : SWIGINTERN int layerObj_setItems(struct layerObj *self,char **items,int numitems){
    4618           0 :         return msLayerSetItems(self, items, numitems);
    4619             :     }
    4620             : SWIGINTERN int layerObj_draw(struct layerObj *self,mapObj *map,imageObj *image){
    4621           0 :         return msDrawLayer(map, self, image);    
    4622             :     }
    4623             : SWIGINTERN int layerObj_drawQuery(struct layerObj *self,mapObj *map,imageObj *image){
    4624           0 :         return msDrawQueryLayer(map, self, image);    
    4625             :     }
    4626           0 : SWIGINTERN int layerObj_queryByFilter(struct layerObj *self,mapObj *map,char *string){
    4627             :         int status;
    4628             :         int retval;
    4629             : 
    4630           0 :         msInitQuery(&(map->query));
    4631             : 
    4632           0 :         map->query.type = MS_QUERY_BY_FILTER;
    4633           0 :         map->query.mode = MS_QUERY_MULTIPLE;
    4634             : 
    4635           0 :         map->query.filter.string = msStrdup(string);
    4636           0 :         map->query.filter.type = MS_EXPRESSION;
    4637             :         
    4638           0 :         map->query.layer = self->index;
    4639           0 :         map->query.rect = map->extent;
    4640             : 
    4641           0 :         status = self->status;
    4642           0 :         self->status = 1;
    4643           0 :         retval = msQueryByFilter(map);
    4644           0 :         self->status = status;
    4645           0 :         return retval;
    4646             :     }
    4647           1 : SWIGINTERN int layerObj_queryByAttributes(struct layerObj *self,mapObj *map,char *qitem,char *qstring,int mode){
    4648             :         int status;
    4649             :         int retval;
    4650             : 
    4651           1 :         msInitQuery(&(map->query));
    4652             :         
    4653           1 :         map->query.type = MS_QUERY_BY_FILTER;
    4654           1 :         map->query.mode = mode;
    4655             : 
    4656           1 :         if(qitem) map->query.filteritem = msStrdup(qitem);
    4657           1 :         if(qstring) {
    4658           1 :           msInitExpression(&map->query.filter);
    4659           1 :           msLoadExpressionString(&map->query.filter, qstring);
    4660             :         }
    4661             : 
    4662           1 :         map->query.layer = self->index;
    4663           1 :         map->query.rect = map->extent;
    4664             : 
    4665           1 :         status = self->status;
    4666           1 :         self->status = 1;
    4667           1 :         retval = msQueryByFilter(map);
    4668           1 :         self->status = status;
    4669             : 
    4670           1 :         return retval;
    4671             :     }
    4672             : SWIGINTERN int layerObj_queryByPoint(struct layerObj *self,mapObj *map,pointObj *point,int mode,double buffer){
    4673             :         int status;
    4674             :         int retval;
    4675             : 
    4676           1 :         msInitQuery(&(map->query));
    4677             : 
    4678           1 :         map->query.type = MS_QUERY_BY_POINT;
    4679           1 :         map->query.mode = mode;
    4680           1 :         map->query.point = *point;
    4681           1 :         map->query.buffer = buffer;
    4682           1 :         map->query.layer = self->index;
    4683             :         
    4684           1 :         status = self->status;
    4685           1 :         self->status = 1;
    4686           1 :         retval = msQueryByPoint(map);
    4687           1 :         self->status = status;
    4688             : 
    4689             :         return retval;
    4690             :     }
    4691             : SWIGINTERN int layerObj_queryByRect(struct layerObj *self,mapObj *map,rectObj rect){
    4692             :         int status;
    4693             :         int retval;
    4694             : 
    4695           1 :         msInitQuery(&(map->query));
    4696             : 
    4697           1 :         map->query.type = MS_QUERY_BY_RECT;
    4698           1 :         map->query.mode = MS_QUERY_MULTIPLE;
    4699           1 :         map->query.rect = rect; 
    4700           1 :         map->query.layer = self->index;
    4701             : 
    4702           1 :         status = self->status;
    4703           1 :         self->status = 1;
    4704           1 :         retval = msQueryByRect(map);
    4705           1 :         self->status = status;
    4706             : 
    4707             :         return retval;
    4708             :     }
    4709             : SWIGINTERN int layerObj_queryByFeatures(struct layerObj *self,mapObj *map,int slayer){
    4710             :         int status;
    4711             :         int retval;
    4712             : 
    4713           0 :         map->query.slayer = slayer;
    4714           0 :         map->query.layer = self->index;
    4715             : 
    4716           0 :         status = self->status;
    4717           0 :         self->status = 1;
    4718           0 :         retval = msQueryByFeatures(map);
    4719           0 :         self->status = status;
    4720             :         return retval;
    4721             :     }
    4722           1 : SWIGINTERN int layerObj_queryByShape(struct layerObj *self,mapObj *map,shapeObj *shape){
    4723             :         int status;
    4724             :         int retval;
    4725             :         
    4726           1 :         msInitQuery(&(map->query));
    4727             : 
    4728           1 :         map->query.type = MS_QUERY_BY_SHAPE;
    4729           1 :         map->query.mode = MS_QUERY_MULTIPLE;
    4730           1 :         map->query.shape = (shapeObj *) malloc(sizeof(shapeObj));
    4731           1 :         msInitShape(map->query.shape);
    4732           1 :         msCopyShape(shape, map->query.shape);
    4733           1 :         map->query.layer = self->index;
    4734             : 
    4735           1 :         status = self->status;
    4736           1 :         self->status = 1;
    4737           1 :         retval = msQueryByShape(map);
    4738           1 :         self->status = status;
    4739           1 :         return retval;
    4740             :     }
    4741             : SWIGINTERN int layerObj_queryByIndex(struct layerObj *self,mapObj *map,int tileindex,int shapeindex,int bAddToQuery){
    4742             :         int status;
    4743             :         int retval;
    4744             :         
    4745           1 :         msInitQuery(&(map->query));
    4746             : 
    4747           1 :         map->query.type = MS_QUERY_BY_INDEX;
    4748           1 :         map->query.mode = MS_QUERY_SINGLE;
    4749           1 :         map->query.tileindex = tileindex;
    4750           1 :         map->query.shapeindex = shapeindex;
    4751           1 :         map->query.clear_resultcache = !bAddToQuery;
    4752           1 :         map->query.layer = self->index;
    4753             : 
    4754           1 :         status = self->status;
    4755           1 :         self->status = 1;
    4756           1 :         retval = msQueryByIndex(map);
    4757           1 :         self->status = status;
    4758             :         return retval;
    4759             :     }
    4760             : SWIGINTERN resultCacheObj *layerObj_getResults(struct layerObj *self){
    4761             :         return self->resultcache;
    4762             :     }
    4763           1 : SWIGINTERN int layerObj_setFilter(struct layerObj *self,char *filter){
    4764           1 :         if (!filter || strlen(filter) == 0) {
    4765           1 :             msFreeExpression(&self->filter);
    4766           1 :             return MS_SUCCESS;
    4767             :         }
    4768           1 :         else return msLoadExpressionString(&self->filter, filter);
    4769             :     }
    4770             : SWIGINTERN char *layerObj_getFilterString(struct layerObj *self){
    4771           1 :         return msGetExpressionString(&(self->filter));
    4772             :     }
    4773             : SWIGINTERN int layerObj_setWKTProjection(struct layerObj *self,char *wkt){
    4774           0 :         self->project = 1;
    4775           0 :         return msOGCWKT2ProjectionObj(wkt, &(self->projection), self->debug);
    4776             :     }
    4777             : SWIGINTERN char *layerObj_getProjection(struct layerObj *self){    
    4778           0 :         return (char *) msGetProjectionString(&(self->projection));
    4779             :     }
    4780             : SWIGINTERN int layerObj_setProjection(struct layerObj *self,char *proj4){
    4781           1 :         self->project = 1;
    4782           1 :         return msLoadProjectionString(&(self->projection), proj4);
    4783             :     }
    4784           1 : SWIGINTERN int layerObj_addFeature(struct layerObj *self,shapeObj *shape){    
    4785           1 :         self->connectiontype = MS_INLINE;
    4786           1 :         if(self->features != NULL && self->features->tailifhead != NULL) 
    4787           1 :             shape->index = self->features->tailifhead->shape.index + 1;
    4788             :         else 
    4789           1 :             shape->index = 0;
    4790           1 :         if (insertFeatureList(&(self->features), shape) == NULL) 
    4791             :         return MS_FAILURE;
    4792           1 :         return MS_SUCCESS;
    4793             :     }
    4794             : SWIGINTERN int layerObj_getNumFeatures(struct layerObj *self){
    4795           1 :         return msLayerGetNumFeatures(self);
    4796             :     }
    4797             : SWIGINTERN rectObj *layerObj_getExtent(struct layerObj *self){
    4798             :         rectObj *extent;
    4799           1 :         extent = (rectObj *) malloc(sizeof(rectObj));
    4800           1 :         msLayerGetExtent(self, extent);
    4801             :         return extent;
    4802             :     }
    4803           1 : SWIGINTERN int layerObj_setExtent(struct layerObj *self,double minx,double miny,double maxx,double maxy){
    4804           1 :         if (minx > maxx || miny > maxy) {
    4805           0 :             msSetError(34,
    4806             :                 "{ 'minx': %f , 'miny': %f , 'maxx': %f , 'maxy': %f }",
    4807             :                 "layerObj::setExtent()", minx, miny, maxx, maxy);
    4808           0 :             return MS_FAILURE;
    4809             :         }
    4810             : 
    4811           1 :         return msLayerSetExtent(self, minx, miny, maxx, maxy);
    4812             :     }
    4813           0 : SWIGINTERN char *layerObj_getMetaData(struct layerObj *self,char *name){
    4814             :         char *value = NULL;
    4815           0 :         if (!name) {
    4816           0 :             msSetError(16, "NULL key", "getMetaData");
    4817             :         }
    4818             :      
    4819           0 :         value = (char *) msLookupHashTable(&(self->metadata), name);
    4820             :     /*
    4821             :     Umberto, 05/17/2006
    4822             :     Exceptions should be reserved for situations when a serious error occurred
    4823             :     and normal program flow must be interrupted.
    4824             :     In this case returning null should be more that enough.
    4825             :     */
    4826             : 
    4827           0 :         if (!value) {
    4828           0 :             msSetError(16, "Key %s does not exist", "getMetaData", name);
    4829           0 :             return NULL;
    4830             :         }
    4831             : 
    4832             :         return value;
    4833             :     }
    4834             : SWIGINTERN int layerObj_setMetaData(struct layerObj *self,char *name,char *value){
    4835           0 :         if (msInsertHashTable(&(self->metadata), name, value) == NULL)
    4836             :         return MS_FAILURE;
    4837             :         return MS_SUCCESS;
    4838             :     }
    4839             : SWIGINTERN int layerObj_removeMetaData(struct layerObj *self,char *name){
    4840           0 :         return(msRemoveHashTable(&(self->metadata), name));
    4841             :     }
    4842             : SWIGINTERN char *layerObj_getFirstMetaDataKey(struct layerObj *self){
    4843           1 :         return (char *) msFirstKeyFromHashTable(&(self->metadata));
    4844             :     }
    4845             : SWIGINTERN char *layerObj_getNextMetaDataKey(struct layerObj *self,char *lastkey){
    4846           1 :         return (char *) msNextKeyFromHashTable(&(self->metadata), lastkey);
    4847             :     }
    4848             : SWIGINTERN char *layerObj_getWMSFeatureInfoURL(struct layerObj *self,mapObj *map,int click_x,int click_y,int feature_count,char *info_format){
    4849           0 :         return (char *) msWMSGetFeatureInfoURL(map, self, click_x, click_y,
    4850             :                feature_count, info_format);
    4851             :     }
    4852             : SWIGINTERN char *layerObj_executeWFSGetFeature(struct layerObj *self,layerObj *layer){
    4853           0 :         return (char *) msWFSExecuteGetFeature(layer);
    4854             :     }
    4855             : SWIGINTERN int layerObj_applySLD(struct layerObj *self,char *sld,char *stylelayer){
    4856           0 :       return msSLDApplySLD(self->map, sld, self->index, stylelayer, NULL);
    4857             :     }
    4858             : SWIGINTERN int layerObj_applySLDURL(struct layerObj *self,char *sld,char *stylelayer){
    4859           0 :       return msSLDApplySLDURL(self->map, sld, self->index, stylelayer, NULL);
    4860             :     }
    4861             : SWIGINTERN char *layerObj_generateSLD(struct layerObj *self){
    4862           0 :         return (char *) msSLDGenerateSLD(self->map, self->index, NULL);
    4863             :     }
    4864           1 : SWIGINTERN int layerObj_isVisible(struct layerObj *self){
    4865           1 :         if (!self->map)
    4866             :         {
    4867           0 :             msSetError(12,
    4868             :                 "visibility has no meaning outside of a map context",
    4869             :                 "isVisible()");
    4870           0 :             return MS_FAILURE;
    4871             :         }
    4872           1 :         return msLayerIsVisible(self->map, self);
    4873             :     }
    4874             : SWIGINTERN int layerObj_moveClassUp(struct layerObj *self,int index){
    4875           0 :         return msMoveClassUp(self, index);
    4876             :     }
    4877             : SWIGINTERN int layerObj_moveClassDown(struct layerObj *self,int index){
    4878           0 :         return msMoveClassDown(self, index);
    4879             :     }
    4880             : SWIGINTERN void layerObj_setProcessingKey(struct layerObj *self,char const *key,char const *value){
    4881           0 :        msLayerSetProcessingKey( self, key, value );
    4882             :     }
    4883             : SWIGINTERN void layerObj_setProcessing(struct layerObj *self,char const *directive){
    4884           1 :         msLayerAddProcessing( self, directive );
    4885             :     }
    4886             : SWIGINTERN void layerObj_addProcessing(struct layerObj *self,char const *directive){
    4887           0 :         msLayerAddProcessing( self, directive );
    4888             :     }
    4889             : SWIGINTERN char *layerObj_getProcessing(struct layerObj *self,int index){
    4890           1 :         return (char *) msLayerGetProcessing(self, index);
    4891             :     }
    4892             : SWIGINTERN char *layerObj_getProcessingKey(struct layerObj *self,char const *key){
    4893           0 :       return (char *) msLayerGetProcessingKey(self, key);
    4894             :     }
    4895             : SWIGINTERN int layerObj_clearProcessing(struct layerObj *self){
    4896           1 :         return msLayerClearProcessing(self);
    4897             :     }
    4898           0 : SWIGINTERN int layerObj_setConnectionType(struct layerObj *self,int connectiontype,char const *library_str){    
    4899             :         /* Caller is responsible to close previous layer correctly before
    4900             :          * calling msConnectLayer() 
    4901             :          */
    4902           0 :         if (msLayerIsOpen(self))
    4903           0 :           msLayerClose(self);
    4904           0 :         return msConnectLayer(self, connectiontype, library_str);
    4905             :     }
    4906             : SWIGINTERN int layerObj_getClassIndex(struct layerObj *self,mapObj *map,shapeObj *shape,int *classgroup,int numclasses){
    4907           0 :         return msShapeGetClass(self, map, shape, classgroup, numclasses);
    4908             :     }
    4909             : SWIGINTERN char *layerObj_getGeomTransform(struct layerObj *self){
    4910             :       return self->_geomtransform.string;
    4911             :     }
    4912           0 : SWIGINTERN void layerObj_setGeomTransform(struct layerObj *self,char *transform){
    4913           0 :       msFree(self->_geomtransform.string);
    4914           0 :       if (!transform || strlen(transform) > 0) {
    4915           0 :         self->_geomtransform.string = msStrdup(transform);
    4916           0 :         self->_geomtransform.type = MS_GEOMTRANSFORM_EXPRESSION;
    4917             :       }
    4918             :       else {
    4919           0 :         self->_geomtransform.type = MS_GEOMTRANSFORM_NONE;
    4920           0 :         self->_geomtransform.string = NULL;
    4921             :       }
    4922           0 :     }
    4923           1 : SWIGINTERN char *layerObj_getItemType(struct layerObj *self,int i){
    4924             : 
    4925             :         char *itemType = NULL;
    4926             : 
    4927           1 :         if (i >= 0 && i < self->numitems) {
    4928             :             gmlItemListObj *item_list;
    4929           1 :             item_list = msGMLGetItems(self, "G");
    4930           1 :             if (item_list != NULL) {
    4931           1 :                 gmlItemObj *item = item_list->items + i;
    4932           1 :                 itemType = msStrdup(item->type);
    4933           1 :                 msGMLFreeItems(item_list); // destroy the original list
    4934             :             }
    4935             :         }
    4936             : 
    4937           1 :         return itemType;
    4938             :     }
    4939           1 : SWIGINTERN struct mapObj *new_mapObj(char *filename){
    4940           1 :         if (filename && strlen(filename))
    4941           1 :             return msLoadMap(filename, NULL);
    4942             :         else { /* create an empty map, no layers etc... */
    4943           1 :             return msNewMapObj();
    4944             :         }      
    4945             :     }
    4946             : SWIGINTERN void delete_mapObj(struct mapObj *self){
    4947           1 :         msFreeMap(self);
    4948             :     }
    4949           1 : SWIGINTERN mapObj *mapObj_clone(struct mapObj *self){
    4950             :         mapObj *dstMap;
    4951           1 :         dstMap = msNewMapObj();
    4952           1 :         if (msCopyMap(dstMap, self) != MS_SUCCESS) {
    4953           0 :             msFreeMap(dstMap);
    4954             :             dstMap = NULL;
    4955             :         }
    4956           1 :         return dstMap;
    4957             :     }
    4958             : SWIGINTERN int mapObj_insertLayer(struct mapObj *self,layerObj *layer,int index){
    4959           1 :         return msInsertLayer(self, layer, index);  
    4960             :     }
    4961             : SWIGINTERN layerObj *mapObj_removeLayer(struct mapObj *self,int index){
    4962           1 :         layerObj *layer=msRemoveLayer(self, index);
    4963           1 :         MS_REFCNT_INCR(layer);
    4964             :         return layer;
    4965             :     }
    4966             : SWIGINTERN int mapObj_setExtent(struct mapObj *self,double minx,double miny,double maxx,double maxy){
    4967           1 :         return msMapSetExtent( self, minx, miny, maxx, maxy );
    4968             :     }
    4969             : SWIGINTERN int mapObj_offsetExtent(struct mapObj *self,double x,double y){
    4970           0 :         return msMapOffsetExtent( self, x, y );
    4971             :     }
    4972             : SWIGINTERN int mapObj_scaleExtent(struct mapObj *self,double zoomfactor,double minscaledenom,double maxscaledenom){
    4973           0 :         return msMapScaleExtent( self, zoomfactor, minscaledenom, maxscaledenom );
    4974             :     }
    4975             : SWIGINTERN int mapObj_setCenter(struct mapObj *self,pointObj *center){
    4976           0 :         return msMapSetCenter( self, center );
    4977             :     }
    4978             : SWIGINTERN int mapObj_setSize(struct mapObj *self,int width,int height){
    4979           1 :         return msMapSetSize(self, width, height);
    4980             :     }
    4981             : SWIGINTERN void mapObj_pixelToGeoref(struct mapObj *self,double pixPosX,double pixPosY,pointObj *geoPos){
    4982           0 :        geoPos->x = self->gt.geotransform[0] + self->gt.geotransform[1] * pixPosX + self->gt.geotransform[2] * pixPosY;
    4983           0 :        geoPos->y = self->gt.geotransform[3] + self->gt.geotransform[4] * pixPosX + self->gt.geotransform[5] * pixPosY;
    4984             :     }
    4985             : SWIGINTERN double mapObj_getRotation(struct mapObj *self){
    4986             :         return self->gt.rotation_angle;
    4987             :     }
    4988             : SWIGINTERN int mapObj_setRotation(struct mapObj *self,double rotation_angle){
    4989           0 :         return msMapSetRotation( self, rotation_angle );
    4990             :     }
    4991           1 : SWIGINTERN layerObj *mapObj_getLayer(struct mapObj *self,int i){
    4992           1 :       if(i >= 0 && i < self->numlayers) {
    4993           1 :           MS_REFCNT_INCR(self->layers[i]);
    4994           1 :           return (self->layers[i]); /* returns an EXISTING layer */
    4995             :       } else {
    4996             :         return NULL;
    4997             :       }
    4998             :     }
    4999           1 : SWIGINTERN layerObj *mapObj_getLayerByName(struct mapObj *self,char *name){
    5000             :       int i;
    5001             : 
    5002           1 :       i = msGetLayerIndex(self, name);
    5003             : 
    5004           1 :       if(i != -1) {
    5005           1 :         MS_REFCNT_INCR(self->layers[i]);
    5006           1 :         return (self->layers[i]); /* returns an EXISTING layer */
    5007             :       }
    5008             :       else
    5009             :         return NULL;
    5010             :     }
    5011             : SWIGINTERN int mapObj_getSymbolByName(struct mapObj *self,char *name){
    5012           0 :       return msGetSymbolIndex(&self->symbolset, name, 1);
    5013             :     }
    5014           0 : SWIGINTERN void mapObj_prepareQuery(struct mapObj *self){
    5015             :       int status;
    5016             : 
    5017           0 :       status = msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &self->scaledenom);
    5018           0 :       if(status != MS_SUCCESS) self->scaledenom = -1;
    5019           0 :     }
    5020             : SWIGINTERN imageObj *mapObj_prepareImage(struct mapObj *self){
    5021           1 :       return msPrepareImage(self, 0);
    5022             :     }
    5023           1 : SWIGINTERN void mapObj_setImageType(struct mapObj *self,char *imagetype){
    5024             :         outputFormatObj *format;
    5025             : 
    5026           1 :         format = msSelectOutputFormat( self, imagetype );
    5027           1 :         if( format == NULL )
    5028           0 :             msSetError(12, "Unable to find IMAGETYPE '%s'.", 
    5029             :                "setImageType()", imagetype );
    5030             :         else
    5031             :         {  
    5032           1 :             msFree( self->imagetype );
    5033           1 :             self->imagetype = msStrdup(imagetype);
    5034           1 :             msApplyOutputFormat( &(self->outputformat), format, -1111, 
    5035             :                                  -1111, -1111 );
    5036             :         }
    5037           1 :     }
    5038           1 : SWIGINTERN void mapObj_selectOutputFormat(struct mapObj *self,char *imagetype){
    5039             :         outputFormatObj *format;
    5040             : 
    5041           1 :         format = msSelectOutputFormat( self, imagetype );
    5042           1 :         if ( format == NULL )
    5043           1 :             msSetError(12, "Unable to find IMAGETYPE '%s'.", 
    5044             :                        "setImageType()", imagetype );
    5045             :         else
    5046             :         {   
    5047           1 :             msFree( self->imagetype );
    5048           1 :             self->imagetype = msStrdup(imagetype);
    5049           1 :             msApplyOutputFormat( &(self->outputformat), format, -1111, 
    5050             :                                  -1111, -1111 );
    5051             :         }
    5052           1 :     }
    5053           0 : SWIGINTERN outputFormatObj *mapObj_getOutputFormat(struct mapObj *self,int i){
    5054           0 :       if(i >= 0 && i < self->numoutputformats) {
    5055           0 :           MS_REFCNT_INCR(self->outputformatlist[i]);
    5056           0 :           return (self->outputformatlist[i]); 
    5057             :       } else {
    5058             :         return NULL;
    5059             :       }
    5060             :     }
    5061             : SWIGINTERN void mapObj_setOutputFormat(struct mapObj *self,outputFormatObj *format){
    5062           0 :         msApplyOutputFormat( &(self->outputformat), format, -1111, 
    5063             :                              -1111, -1111 );
    5064             :     }
    5065             : SWIGINTERN imageObj *mapObj_draw(struct mapObj *self){
    5066             :   
    5067             : 
    5068             : 
    5069             : 
    5070             : 
    5071             : 
    5072             : 
    5073             : 
    5074           1 :       return msDrawMap(self, 0);
    5075             :   
    5076             :     }
    5077             : SWIGINTERN imageObj *mapObj_drawQuery(struct mapObj *self){
    5078           0 :       return msDrawMap(self, 1);
    5079             :     }
    5080             : SWIGINTERN imageObj *mapObj_drawLegend(struct mapObj *self,int scale_independent){
    5081           0 :       return msDrawLegend(self, scale_independent, NULL);
    5082             :     }
    5083             : SWIGINTERN imageObj *mapObj_drawScalebar(struct mapObj *self){
    5084           0 :       return msDrawScalebar(self);
    5085             :     }
    5086             : SWIGINTERN imageObj *mapObj_drawReferenceMap(struct mapObj *self){
    5087           0 :       return msDrawReferenceMap(self);
    5088             :     }
    5089             : SWIGINTERN int mapObj_embedScalebar(struct mapObj *self,imageObj *image){ 
    5090           0 :       return msEmbedScalebar(self, image);
    5091             :     }
    5092             : SWIGINTERN int mapObj_embedLegend(struct mapObj *self,imageObj *image){ 
    5093           0 :       return msEmbedLegend(self, image);
    5094             :     }
    5095             : SWIGINTERN int mapObj_drawLabelCache(struct mapObj *self,imageObj *image){
    5096           0 :       return msDrawLabelCache(self,image);
    5097             :     }
    5098           0 : SWIGINTERN int mapObj_queryByFilter(struct mapObj *self,char *string){
    5099           0 :       msInitQuery(&(self->query));
    5100             : 
    5101           0 :       self->query.type = MS_QUERY_BY_FILTER;
    5102           0 :       self->query.mode = MS_QUERY_MULTIPLE;
    5103             : 
    5104           0 :       self->query.filter.string = msStrdup(string);
    5105           0 :       self->query.filter.type = MS_EXPRESSION;
    5106             : 
    5107           0 :       self->query.rect = self->extent;
    5108             : 
    5109           0 :       return msQueryByFilter(self);
    5110             :     }
    5111             : SWIGINTERN int mapObj_queryByPoint(struct mapObj *self,pointObj *point,int mode,double buffer){
    5112           1 :       msInitQuery(&(self->query));
    5113             : 
    5114           1 :       self->query.type = MS_QUERY_BY_POINT;
    5115           1 :       self->query.mode = mode;
    5116           1 :       self->query.point = *point;
    5117           1 :       self->query.buffer = buffer;
    5118             : 
    5119           1 :       return msQueryByPoint(self);
    5120             :     }
    5121             : SWIGINTERN int mapObj_queryByRect(struct mapObj *self,rectObj rect){
    5122           0 :       msInitQuery(&(self->query));
    5123             : 
    5124           0 :       self->query.type = MS_QUERY_BY_RECT;
    5125           0 :       self->query.mode = MS_QUERY_MULTIPLE;
    5126           0 :       self->query.rect = rect;
    5127             : 
    5128           0 :       return msQueryByRect(self);
    5129             :     }
    5130             : SWIGINTERN int mapObj_queryByFeatures(struct mapObj *self,int slayer){
    5131           0 :       self->query.slayer = slayer;
    5132           0 :       return msQueryByFeatures(self);
    5133             :     }
    5134           0 : SWIGINTERN int mapObj_queryByShape(struct mapObj *self,shapeObj *shape){
    5135           0 :       msInitQuery(&(self->query));
    5136             :       
    5137           0 :       self->query.type = MS_QUERY_BY_SHAPE;
    5138           0 :       self->query.mode = MS_QUERY_MULTIPLE;
    5139           0 :       self->query.shape = (shapeObj *) malloc(sizeof(shapeObj));
    5140           0 :       msInitShape(self->query.shape);
    5141           0 :       msCopyShape(shape, self->query.shape);
    5142             : 
    5143           0 :       return msQueryByShape(self);
    5144             :     }
    5145             : SWIGINTERN int mapObj_setWKTProjection(struct mapObj *self,char *wkt){
    5146           1 :       return msOGCWKT2ProjectionObj(wkt, &(self->projection), self->debug);
    5147             :     }
    5148             : SWIGINTERN char *mapObj_getProjection(struct mapObj *self){
    5149           1 :       return msGetProjectionString(&(self->projection));
    5150             :     }
    5151             : SWIGINTERN int mapObj_setProjection(struct mapObj *self,char *proj4){
    5152           1 :       return msLoadProjectionString(&(self->projection), proj4);
    5153             :     }
    5154             : SWIGINTERN int mapObj_save(struct mapObj *self,char *filename){
    5155           1 :       return msSaveMap(self, filename);
    5156             :     }
    5157             : SWIGINTERN int mapObj_saveQuery(struct mapObj *self,char *filename,int results){
    5158           1 :       return msSaveQuery(self, filename, results);
    5159             :     }
    5160             : SWIGINTERN int mapObj_loadQuery(struct mapObj *self,char *filename){
    5161           1 :       return msLoadQuery(self, filename);
    5162             :     }
    5163             : SWIGINTERN void mapObj_freeQuery(struct mapObj *self,int qlayer){
    5164           1 :       msQueryFree(self, qlayer);
    5165             :     }
    5166             : SWIGINTERN int mapObj_saveQueryAsGML(struct mapObj *self,char *filename,char const *ns){
    5167           0 :       return msGMLWriteQuery(self, filename, ns);
    5168             :     }
    5169           1 : SWIGINTERN char *mapObj_getMetaData(struct mapObj *self,char *name){
    5170             :       char *value = NULL;
    5171           1 :       if (!name) {
    5172           0 :         msSetError(16, "NULL key", "getMetaData");
    5173             :       }
    5174             :        
    5175           1 :       value = (char *) msLookupHashTable(&(self->web.metadata), name);
    5176           1 :       if (!value) {
    5177           1 :         msSetError(16, "Key %s does not exist", "getMetaData", name);
    5178           1 :         return NULL;
    5179             :       }
    5180             :       return value;
    5181             :     }
    5182             : SWIGINTERN int mapObj_setMetaData(struct mapObj *self,char *name,char *value){
    5183           1 :       if (msInsertHashTable(&(self->web.metadata), name, value) == NULL)
    5184             :           return MS_FAILURE;
    5185             :       return MS_SUCCESS;
    5186             :     }
    5187             : SWIGINTERN int mapObj_removeMetaData(struct mapObj *self,char *name){
    5188           0 :       return(msRemoveHashTable(&(self->web.metadata), name));
    5189             :     }
    5190             : SWIGINTERN char *mapObj_getFirstMetaDataKey(struct mapObj *self){
    5191           1 :       return (char *) msFirstKeyFromHashTable(&(self->web.metadata));
    5192             :     }
    5193             : SWIGINTERN char *mapObj_getNextMetaDataKey(struct mapObj *self,char *lastkey){
    5194           1 :       return (char *) msNextKeyFromHashTable(&(self->web.metadata), lastkey);
    5195             :     }
    5196           0 : SWIGINTERN int mapObj_setSymbolSet(struct mapObj *self,char *szFileName){
    5197           0 :       msFreeSymbolSet(&self->symbolset);
    5198           0 :       msInitSymbolSet(&self->symbolset);
    5199             : 
    5200           0 :       self->symbolset.filename = msStrdup(szFileName);
    5201             : 
    5202             :       /* Symbolset shares same fontset as main mapfile */
    5203           0 :       self->symbolset.fontset = &(self->fontset);
    5204             : 
    5205           0 :       return msLoadSymbolSet(&self->symbolset, self);
    5206             :     }
    5207             : SWIGINTERN int mapObj_getNumSymbols(struct mapObj *self){
    5208             :       return self->symbolset.numsymbols;
    5209             :     }
    5210           0 : SWIGINTERN int mapObj_setFontSet(struct mapObj *self,char *filename){
    5211           0 :       msFreeFontSet(&(self->fontset));
    5212           0 :       msInitFontSet(&(self->fontset));
    5213             : 
    5214           0 :       self->fontset.filename = msStrdup(filename);
    5215             : 
    5216           0 :       return msLoadFontSet(&(self->fontset), self);
    5217             :     }
    5218             : SWIGINTERN int mapObj_saveMapContext(struct mapObj *self,char *szFileName){
    5219           0 :       return msSaveMapContext(self, szFileName);
    5220             :     }
    5221             : SWIGINTERN int mapObj_loadMapContext(struct mapObj *self,char *szFileName,int useUniqueNames){
    5222           0 :       return msLoadMapContext(self, szFileName, useUniqueNames);
    5223             :     }
    5224             : SWIGINTERN int mapObj_moveLayerUp(struct mapObj *self,int layerindex){
    5225           0 :       return msMoveLayerUp(self, layerindex);
    5226             :     }
    5227             : SWIGINTERN int mapObj_moveLayerDown(struct mapObj *self,int layerindex){
    5228           0 :       return msMoveLayerDown(self, layerindex);
    5229             :     }
    5230           0 : SWIGINTERN intarray *mapObj_getLayersDrawingOrder(struct mapObj *self){
    5231             :       int i;
    5232             :       intarray *order;
    5233           0 :       order = new_intarray(self->numlayers);
    5234           0 :       for (i=0; i<self->numlayers; i++)
    5235             :           
    5236           0 :           intarray___setitem__(order, i, self->layerorder[i]);
    5237             :           
    5238             : 
    5239             : 
    5240           0 :       return order;
    5241             :     }
    5242             : SWIGINTERN int mapObj_setLayersDrawingOrder(struct mapObj *self,int *panIndexes){
    5243           0 :       return msSetLayersdrawingOrder(self, panIndexes); 
    5244             :     }
    5245             : SWIGINTERN void mapObj_setConfigOption(struct mapObj *self,char *key,char *value){
    5246           0 :       msSetConfigOption(self,key,value);
    5247             :     }
    5248             : SWIGINTERN char *mapObj_getConfigOption(struct mapObj *self,char *key){
    5249           0 :       return (char *) msGetConfigOption(self,key);
    5250             :     }
    5251             : SWIGINTERN void mapObj_applyConfigOptions(struct mapObj *self){
    5252           0 :       msApplyMapConfigOptions( self );
    5253             :     }
    5254             : SWIGINTERN int mapObj_applySLD(struct mapObj *self,char *sld){
    5255           0 :       return msSLDApplySLD(self, sld, -1, NULL, NULL);
    5256             :     }
    5257             : SWIGINTERN int mapObj_applySLDURL(struct mapObj *self,char *sld){
    5258           0 :       return msSLDApplySLDURL(self, sld, -1, NULL, NULL);
    5259             :     }
    5260             : SWIGINTERN char *mapObj_generateSLD(struct mapObj *self,char *sldVersion){
    5261           1 :         return (char *) msSLDGenerateSLD(self, -1, sldVersion);
    5262             :     }
    5263             : SWIGINTERN char *mapObj_processTemplate(struct mapObj *self,int bGenerateImages,char **names,char **values,int numentries){
    5264           0 :         return msProcessTemplate(self, bGenerateImages, names, values,
    5265             :                                  numentries);
    5266             :     }
    5267             : SWIGINTERN char *mapObj_processLegendTemplate(struct mapObj *self,char **names,char **values,int numentries){
    5268           0 :         return msProcessLegendTemplate(self, names, values, numentries);
    5269             :     }
    5270             : SWIGINTERN char *mapObj_processQueryTemplate(struct mapObj *self,char **names,char **values,int numentries){
    5271           0 :         return msProcessQueryTemplate(self, 1, names, values, numentries);
    5272             :     }
    5273             : SWIGINTERN outputFormatObj *mapObj_getOutputFormatByName(struct mapObj *self,char *name){
    5274           0 :         return msSelectOutputFormat(self, name); 
    5275             :     }
    5276             : SWIGINTERN int mapObj_appendOutputFormat(struct mapObj *self,outputFormatObj *format){
    5277           1 :         return msAppendOutputFormat(self, format);
    5278             :     }
    5279             : SWIGINTERN int mapObj_removeOutputFormat(struct mapObj *self,char *name){
    5280           1 :         return msRemoveOutputFormat(self, name);
    5281             :     }
    5282             : SWIGINTERN int mapObj_loadOWSParameters(struct mapObj *self,cgiRequestObj *request,char *wmtver_string){
    5283           1 :         return msMapLoadOWSParameters(self, request, wmtver_string);
    5284             :     }
    5285             : SWIGINTERN int mapObj_OWSDispatch(struct mapObj *self,cgiRequestObj *req){
    5286           1 :         return msOWSDispatch( self, req, 1 );
    5287             :     }
    5288             : SWIGINTERN char *mapObj_convertToString(struct mapObj *self){
    5289           0 :         return msWriteMapToString(self);
    5290             :     }
    5291             : SWIGINTERN void mapObj_applyDefaultSubstitutions(struct mapObj *self){
    5292           1 :         msApplyDefaultSubstitutions(self);
    5293             :     }
    5294             : SWIGINTERN void mapObj_applySubstitutions(struct mapObj *self,char **names,char **values,int npairs){
    5295           1 :         msApplySubstitutions(self, names, values, npairs);
    5296             :     }
    5297           1 : SWIGINTERN int mapObj_zoomPoint(struct mapObj *self,int zoomfactor,pointObj *poPixPos,int width,int height,rectObj *poGeorefExt,rectObj *poMaxGeorefExt){
    5298             :         double      dfGeoPosX, dfGeoPosY;
    5299             :         double      dfDeltaX, dfDeltaY;
    5300             :         rectObj     oNewGeorefExt;    
    5301             :         double      dfNewScale;
    5302             :         int         bMaxExtSet;
    5303             :         double      dfDeltaExt;
    5304             :         double dX, dY;
    5305             :         
    5306           1 :         dfNewScale = 0.0;
    5307             :         bMaxExtSet = 0;
    5308             :         dfDeltaExt = -1.0;
    5309             : 
    5310           1 :         if (poMaxGeorefExt != NULL) { bMaxExtSet = 1; }
    5311             : 
    5312             :         /* ----------------------------------------------------------- */
    5313             :         /*      check the validity of the parameters.                  */
    5314             :         /* ----------------------------------------------------------- */
    5315           1 :         if (zoomfactor == 0 || width <= 0 || height <= 0 || poGeorefExt == NULL || poPixPos == NULL) {
    5316           1 :             msSetError(12, "Incorrect arguments", "mapscript::mapObj::zoomPoint()");
    5317           1 :             return MS_FAILURE;
    5318             :         }
    5319             : 
    5320             :         /* ----------------------------------------------------------- */
    5321             :         /*      check if the values passed are consistent min > max.   */
    5322             :         /* ----------------------------------------------------------- */
    5323           1 :         if (poGeorefExt->minx >= poGeorefExt->maxx)  {
    5324           1 :             msSetError(12, "Georeferenced coordinates minx >= maxx",  "mapscript::mapObj::zoomPoint()");
    5325           1 :             return MS_FAILURE;
    5326             :         }
    5327           1 :         if (poGeorefExt->miny >= poGeorefExt->maxy)  {
    5328           0 :             msSetError(12, "Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomPoint()");
    5329           0 :             return MS_FAILURE;
    5330             :         }
    5331             : 
    5332           1 :         if (bMaxExtSet == 1) {
    5333           1 :             if (poMaxGeorefExt->minx >= poMaxGeorefExt->maxx) {
    5334           0 :                 msSetError(12, "Max Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomPoint()");
    5335           0 :                 return MS_FAILURE;
    5336             :             }
    5337           1 :             if (poMaxGeorefExt->miny >= poMaxGeorefExt->maxy) {
    5338           0 :                 msSetError(12, "Max Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomPoint()");
    5339             :             }
    5340             :         }
    5341             :    
    5342           1 :         dfDeltaX = poGeorefExt->maxx - poGeorefExt->minx;
    5343           1 :         dfDeltaY = poGeorefExt->maxy - poGeorefExt->miny;
    5344           1 :         dX = dfDeltaX/((double)width);
    5345           1 :         dY = dfDeltaY/((double)height);
    5346           1 :         dfGeoPosX = poGeorefExt->minx + dX * (double)poPixPos->x;
    5347           1 :         dfGeoPosY = poGeorefExt->maxy - dY * (double)poPixPos->y;
    5348             : 
    5349           1 :         if (self->gt.rotation_angle != 0) {
    5350           0 :             dfGeoPosX = self->gt.geotransform[0] + self->gt.geotransform[1] * (double)poPixPos->x + self->gt.geotransform[2] * (double)poPixPos->y;
    5351           0 :             dfGeoPosY = self->gt.geotransform[3] + self->gt.geotransform[4] * (double)poPixPos->x + self->gt.geotransform[5] * (double)poPixPos->y;
    5352             :         }
    5353             :         
    5354             :         /* --- -------------------------------------------------------- */
    5355             :         /*      zoom in                                                 */
    5356             :         /* ------------------------------------------------------------ */
    5357           1 :         if (zoomfactor > 1) {
    5358           1 :             oNewGeorefExt.minx = dfGeoPosX - (dfDeltaX/(2*zoomfactor));        
    5359           1 :             oNewGeorefExt.miny = dfGeoPosY - (dfDeltaY/(2*zoomfactor));        
    5360           1 :             oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaX/(2*zoomfactor));        
    5361           1 :             oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaY/(2*zoomfactor));
    5362             :         }
    5363             : 
    5364           1 :         if (zoomfactor < 0) {
    5365           1 :             oNewGeorefExt.minx = dfGeoPosX - (dfDeltaX/2)*(abs(zoomfactor));    
    5366           1 :             oNewGeorefExt.miny = dfGeoPosY - (dfDeltaY/2)*(abs(zoomfactor));    
    5367           1 :             oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaX/2)*(abs(zoomfactor));    
    5368           1 :             oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaY/2)*(abs(zoomfactor));
    5369             :         }
    5370             : 
    5371           1 :         if (zoomfactor == 1) {
    5372           1 :             oNewGeorefExt.minx = dfGeoPosX - (dfDeltaX/2);
    5373           1 :             oNewGeorefExt.miny = dfGeoPosY - (dfDeltaY/2);
    5374           1 :             oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaX/2);
    5375           1 :             oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaY/2);
    5376             :         }
    5377             : 
    5378             :         /* ------------------------------------------------------------ */
    5379             :         /*   if the min and max scale are set in the map file, we will  */
    5380             :         /*   use them to test before zooming.                           */
    5381             :         /* ------------------------------------------------------------ */
    5382           1 :         msAdjustExtent(&oNewGeorefExt, self->width, self->height);
    5383           1 :         msCalculateScale(oNewGeorefExt, self->units, self->width, self->height, self->resolution, &dfNewScale);
    5384             :     
    5385           1 :         if (self->web.maxscaledenom > 0) {
    5386           0 :             if (zoomfactor < 0 && dfNewScale > self->web.maxscaledenom) {
    5387             :                 return MS_FAILURE;
    5388             :             }
    5389             :         }
    5390             : 
    5391             :         /* ============================================================ */
    5392             :         /*  we do a special case for zoom in : we try to zoom as much as */
    5393             :         /*  possible using the mincale set in the .map.                 */
    5394             :         /* ============================================================ */
    5395           1 :         if (self->web.minscaledenom > 0 && dfNewScale < self->web.minscaledenom && zoomfactor > 1) {
    5396             :             /* To be consistent in swig mapscript and PHP mapscript, 
    5397             :                use the same function to calculate the delta extents. */
    5398           0 :             dfDeltaExt = GetDeltaExtentsUsingScale(self->web.minscaledenom, self->units, dfGeoPosY, 
    5399             :                                                    self->width, self->resolution);
    5400             : 
    5401           0 :             if (dfDeltaExt > 0.0) {
    5402           0 :                 oNewGeorefExt.minx = dfGeoPosX - (dfDeltaExt/2);
    5403           0 :                 oNewGeorefExt.miny = dfGeoPosY - (dfDeltaExt/2);
    5404           0 :                 oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaExt/2);
    5405           0 :                 oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaExt/2);
    5406             :             } else
    5407             :                 return MS_FAILURE;
    5408             :         }
    5409             : 
    5410             :         /* ------------------------------------------------------------ */
    5411             :         /*  If the buffer is set, make sure that the extents do not go  */
    5412             :         /*  beyond the buffer.                                          */
    5413             :         /* ------------------------------------------------------------ */
    5414           1 :         if (bMaxExtSet) {
    5415           1 :             dfDeltaX = oNewGeorefExt.maxx - oNewGeorefExt.minx;
    5416           1 :             dfDeltaY = oNewGeorefExt.maxy - oNewGeorefExt.miny;
    5417             :         
    5418             :             /* Make sure Current georef extents is not bigger than 
    5419             :              * max extents */
    5420           1 :             if (dfDeltaX > (poMaxGeorefExt->maxx-poMaxGeorefExt->minx))
    5421             :                 dfDeltaX = poMaxGeorefExt->maxx-poMaxGeorefExt->minx;
    5422           1 :             if (dfDeltaY > (poMaxGeorefExt->maxy-poMaxGeorefExt->miny))
    5423             :                 dfDeltaY = poMaxGeorefExt->maxy-poMaxGeorefExt->miny;
    5424             : 
    5425           1 :             if (oNewGeorefExt.minx < poMaxGeorefExt->minx) {
    5426           1 :                 oNewGeorefExt.minx = poMaxGeorefExt->minx;
    5427           1 :                 oNewGeorefExt.maxx =  oNewGeorefExt.minx + dfDeltaX;
    5428             :             }
    5429           1 :             if (oNewGeorefExt.maxx > poMaxGeorefExt->maxx) {
    5430           0 :                 oNewGeorefExt.maxx = poMaxGeorefExt->maxx;
    5431           0 :                 oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
    5432             :             }
    5433           1 :             if (oNewGeorefExt.miny < poMaxGeorefExt->miny) {
    5434           1 :                 oNewGeorefExt.miny = poMaxGeorefExt->miny;
    5435           1 :                 oNewGeorefExt.maxy =  oNewGeorefExt.miny + dfDeltaY;
    5436             :             }
    5437           1 :             if (oNewGeorefExt.maxy > poMaxGeorefExt->maxy) {
    5438           0 :                 oNewGeorefExt.maxy = poMaxGeorefExt->maxy;
    5439           0 :                 oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
    5440             :             }
    5441             :         }
    5442             :     
    5443             :         /* ------------------------------------------------------------ */
    5444             :         /*      set the map extents with new values.                    */
    5445             :         /* ------------------------------------------------------------ */
    5446           1 :         self->extent.minx = oNewGeorefExt.minx;
    5447           1 :         self->extent.miny = oNewGeorefExt.miny;
    5448           1 :         self->extent.maxx = oNewGeorefExt.maxx;
    5449           1 :         self->extent.maxy = oNewGeorefExt.maxy;
    5450             :     
    5451           1 :         self->cellsize = msAdjustExtent(&(self->extent), self->width, self->height);      
    5452           1 :         dfDeltaX = self->extent.maxx - self->extent.minx;
    5453           1 :         dfDeltaY = self->extent.maxy - self->extent.miny; 
    5454             : 
    5455           1 :         if (bMaxExtSet) {
    5456           1 :             if (self->extent.minx < poMaxGeorefExt->minx) {
    5457           0 :                 self->extent.minx = poMaxGeorefExt->minx;
    5458           0 :                 self->extent.maxx = self->extent.minx + dfDeltaX;
    5459             :             }
    5460           1 :             if (self->extent.maxx > poMaxGeorefExt->maxx) {
    5461           0 :                 self->extent.maxx = poMaxGeorefExt->maxx;
    5462           0 :                 oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
    5463             :             }
    5464           1 :             if (self->extent.miny < poMaxGeorefExt->miny) {
    5465           0 :                 self->extent.miny = poMaxGeorefExt->miny;
    5466           0 :                 self->extent.maxy =  self->extent.miny + dfDeltaY;
    5467             :             }
    5468           1 :             if (self->extent.maxy > poMaxGeorefExt->maxy) {
    5469           0 :                 self->extent.maxy = poMaxGeorefExt->maxy;
    5470           0 :                 oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
    5471             :             }
    5472             :         }
    5473             :     
    5474           1 :         msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &(self->scaledenom));
    5475             : 
    5476           1 :         return MS_SUCCESS;
    5477             :     }
    5478           1 : SWIGINTERN int mapObj_zoomRectangle(struct mapObj *self,rectObj *poPixRect,int width,int height,rectObj *poGeorefExt,rectObj *poMaxGeorefExt){
    5479             :         double      dfDeltaX, dfDeltaY;
    5480             :         rectObj     oNewGeorefExt;    
    5481             :         double      dfNewScale;
    5482             :         double      dfDeltaExt;
    5483             :         double dfMiddleX, dfMiddleY;
    5484             :         int bMaxExtSet;
    5485             :         
    5486             :         bMaxExtSet = 0;
    5487           1 :         dfNewScale = 0.0;
    5488             :         dfDeltaExt = -1.0;
    5489             : 
    5490           1 :         if (poMaxGeorefExt != NULL) bMaxExtSet = 1;
    5491             : 
    5492             :         /* ----------------------------------------------------------- */
    5493             :         /*      check the validity of the parameters.                  */
    5494             :         /* ----------------------------------------------------------- */
    5495           1 :         if (poPixRect == 0 || width <= 0 || height <= 0 || poGeorefExt == NULL) {
    5496           0 :             msSetError(12, "Incorrect arguments", "mapscript::mapObj::zoomRectangle");
    5497           0 :             return MS_FAILURE;
    5498             :         }
    5499             : 
    5500             :         /* ----------------------------------------------------------- */
    5501             :         /*      check if the values passed are consistent min <= max.   */
    5502             :         /* ----------------------------------------------------------- */
    5503           1 :         if (poPixRect->minx >= poPixRect->maxx) {
    5504           0 :             msSetError(12, "image rectangle minx >= maxx", "mapscript::mapObj::zoomRectangle()");
    5505           0 :             return MS_FAILURE;
    5506             :         }
    5507             :         /* This is not a typo: "maxx >= minx". For historical reason, we
    5508             :          * keep this as it is. See documentation for more info about this check. */
    5509           1 :         if (poPixRect->maxy >= poPixRect->miny) {
    5510           1 :             msSetError(12, "image rectangle maxy >= miny", "mapscript::mapObj::zoomRectangle()");
    5511           1 :             return MS_FAILURE;
    5512             :         }
    5513             : 
    5514           1 :         if (poGeorefExt->minx >= poGeorefExt->maxx) {
    5515           0 :             msSetError(12, "Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomRectangle()");
    5516           0 :             return MS_FAILURE;
    5517             :         }
    5518           1 :         if (poGeorefExt->miny >= poGeorefExt->maxy) {
    5519           0 :             msSetError(12, "Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomRectangle()");
    5520           0 :             return MS_FAILURE;
    5521             :         }
    5522             : 
    5523           1 :         if (bMaxExtSet == 1) {
    5524           1 :             if (poMaxGeorefExt->minx >= poMaxGeorefExt->maxx) {
    5525           0 :                 msSetError(12,  "Max Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomRectangle()");
    5526           0 :                 return MS_FAILURE;
    5527             :             }
    5528           1 :             if (poMaxGeorefExt->miny >= poMaxGeorefExt->maxy) {
    5529           0 :                 msSetError(12, "Max Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomRectangle()");
    5530           0 :                 return MS_FAILURE;
    5531             :             }
    5532             :         }
    5533             : 
    5534             :   
    5535             :         /* ----------------------------------------------------------- */
    5536             :         /*   Convert pixel rectangle to georeferenced rectangle        */
    5537             :         /* ----------------------------------------------------------- */
    5538             :         
    5539             :         dfDeltaX = poGeorefExt->maxx - poGeorefExt->minx;
    5540             :         dfDeltaY = poGeorefExt->maxy - poGeorefExt->miny;
    5541             : 
    5542           1 :         oNewGeorefExt.minx = Pix2Georef((int)poPixRect->minx, 0, width, poGeorefExt->minx, poGeorefExt->maxx, 0); 
    5543           1 :         oNewGeorefExt.maxx = Pix2Georef((int)poPixRect->maxx, 0, width, poGeorefExt->minx, poGeorefExt->maxx, 0); 
    5544           1 :         oNewGeorefExt.miny = Pix2Georef((int)poPixRect->miny, 0, height, poGeorefExt->miny, poGeorefExt->maxy, 1); 
    5545           1 :         oNewGeorefExt.maxy = Pix2Georef((int)poPixRect->maxy, 0, height, poGeorefExt->miny, poGeorefExt->maxy, 1); 
    5546             : 
    5547           1 :         msAdjustExtent(&oNewGeorefExt, self->width, self->height);
    5548             : 
    5549             :         /* ------------------------------------------------------------ */
    5550             :         /*   if the min and max scale are set in the map file, we will  */
    5551             :         /*   use them to test before setting extents.                   */
    5552             :         /* ------------------------------------------------------------ */
    5553           1 :         msCalculateScale(oNewGeorefExt, self->units, self->width, self->height, self->resolution, &dfNewScale);
    5554             : 
    5555           1 :         if (self->web.maxscaledenom > 0 &&  dfNewScale > self->web.maxscaledenom)
    5556             :             return MS_FAILURE;
    5557             : 
    5558           1 :         if (self->web.minscaledenom > 0 && dfNewScale <  self->web.minscaledenom) {
    5559           0 :             dfMiddleX = oNewGeorefExt.minx + ((oNewGeorefExt.maxx - oNewGeorefExt.minx)/2);
    5560           0 :             dfMiddleY = oNewGeorefExt.miny + ((oNewGeorefExt.maxy - oNewGeorefExt.miny)/2);
    5561             : 
    5562             :             /* To be consistent in swig mapscript and PHP mapscript, 
    5563             :                use the same function to calculate the delta extents. */
    5564           0 :             dfDeltaExt = GetDeltaExtentsUsingScale(self->web.minscaledenom, self->units, dfMiddleY, self->width, self->resolution);
    5565             : 
    5566           0 :             if (dfDeltaExt > 0.0) {
    5567           0 :                 oNewGeorefExt.minx = dfMiddleX - (dfDeltaExt/2);
    5568           0 :                 oNewGeorefExt.miny = dfMiddleY - (dfDeltaExt/2);
    5569           0 :                 oNewGeorefExt.maxx = dfMiddleX + (dfDeltaExt/2);
    5570           0 :                 oNewGeorefExt.maxy = dfMiddleY + (dfDeltaExt/2);
    5571             :             } else
    5572             :                 return MS_FAILURE;
    5573             :         }
    5574             : 
    5575             :         /* ------------------------------------------------------------ */
    5576             :         /*  If the buffer is set, make sure that the extents do not go  */
    5577             :         /*  beyond the buffer.                                          */
    5578             :         /* ------------------------------------------------------------ */
    5579           1 :         if (bMaxExtSet) {
    5580           1 :             dfDeltaX = oNewGeorefExt.maxx - oNewGeorefExt.minx;
    5581           1 :             dfDeltaY = oNewGeorefExt.maxy - oNewGeorefExt.miny;
    5582             :         
    5583             :             /* Make sure Current georef extents is not bigger 
    5584             :              * than max extents */
    5585           1 :             if (dfDeltaX > (poMaxGeorefExt->maxx-poMaxGeorefExt->minx))
    5586             :                 dfDeltaX = poMaxGeorefExt->maxx-poMaxGeorefExt->minx;
    5587           1 :             if (dfDeltaY > (poMaxGeorefExt->maxy-poMaxGeorefExt->miny))
    5588             :                 dfDeltaY = poMaxGeorefExt->maxy-poMaxGeorefExt->miny;
    5589             : 
    5590           1 :             if (oNewGeorefExt.minx < poMaxGeorefExt->minx) {
    5591           0 :                 oNewGeorefExt.minx = poMaxGeorefExt->minx;
    5592           0 :                 oNewGeorefExt.maxx =  oNewGeorefExt.minx + dfDeltaX;
    5593             :             }
    5594           1 :             if (oNewGeorefExt.maxx > poMaxGeorefExt->maxx) {
    5595           1 :                 oNewGeorefExt.maxx = poMaxGeorefExt->maxx;
    5596           1 :                 oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
    5597             :             }
    5598           1 :             if (oNewGeorefExt.miny < poMaxGeorefExt->miny) {
    5599           1 :                 oNewGeorefExt.miny = poMaxGeorefExt->miny;
    5600           1 :                 oNewGeorefExt.maxy =  oNewGeorefExt.miny + dfDeltaY;
    5601             :             }
    5602           1 :             if (oNewGeorefExt.maxy > poMaxGeorefExt->maxy) {
    5603           0 :                 oNewGeorefExt.maxy = poMaxGeorefExt->maxy;
    5604           0 :                 oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
    5605             :             }
    5606             :         }
    5607             : 
    5608           1 :         self->extent.minx = oNewGeorefExt.minx;
    5609           1 :         self->extent.miny = oNewGeorefExt.miny;
    5610           1 :         self->extent.maxx = oNewGeorefExt.maxx;
    5611           1 :         self->extent.maxy = oNewGeorefExt.maxy;
    5612             : 
    5613           1 :         self->cellsize = msAdjustExtent(&(self->extent), self->width, self->height);    
    5614           1 :         dfDeltaX = self->extent.maxx - self->extent.minx;
    5615           1 :         dfDeltaY = self->extent.maxy - self->extent.miny; 
    5616             : 
    5617           1 :         if (bMaxExtSet) {
    5618           1 :             if (self->extent.minx < poMaxGeorefExt->minx) {
    5619           0 :                 self->extent.minx = poMaxGeorefExt->minx;
    5620           0 :                 self->extent.maxx = self->extent.minx + dfDeltaX;
    5621             :             }
    5622           1 :             if (self->extent.maxx > poMaxGeorefExt->maxx) {
    5623           0 :                 self->extent.maxx = poMaxGeorefExt->maxx;
    5624           0 :                 oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
    5625             :             }
    5626           1 :             if (self->extent.miny < poMaxGeorefExt->miny) {
    5627           0 :                 self->extent.miny = poMaxGeorefExt->miny;
    5628           0 :                 self->extent.maxy =  self->extent.miny + dfDeltaY;
    5629             :             }
    5630           1 :             if (self->extent.maxy > poMaxGeorefExt->maxy) {
    5631           0 :                 self->extent.maxy = poMaxGeorefExt->maxy;
    5632           0 :                 oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
    5633             :             }
    5634             :         }
    5635             : 
    5636           1 :         msCalculateScale(self->extent, self->units, self->width,  self->height, self->resolution, &(self->scaledenom));
    5637             : 
    5638           1 :         return MS_SUCCESS;
    5639             :     }
    5640           1 : SWIGINTERN int mapObj_zoomScale(struct mapObj *self,double scale,pointObj *poPixPos,int width,int height,rectObj *poGeorefExt,rectObj *poMaxGeorefExt){
    5641             :         double      dfGeoPosX, dfGeoPosY;
    5642             :         double      dfDeltaX, dfDeltaY;
    5643             :         rectObj     oNewGeorefExt;    
    5644             :         double      dfNewScale, dfCurrentScale;
    5645             :         int         bMaxExtSet;
    5646             :         int nTmp;
    5647             :         double      dfDeltaExt;
    5648             :         double dX, dY;
    5649             :         
    5650           1 :         dfNewScale = 0.0;
    5651           1 :         dfCurrentScale = 0.0;
    5652             :         nTmp = 0;
    5653             :         bMaxExtSet = 0;
    5654             :         dfDeltaExt = -1.0;
    5655             : 
    5656           1 :         if (poMaxGeorefExt != NULL) { bMaxExtSet = 1; }
    5657             : 
    5658             :         /* ----------------------------------------------------------- */
    5659             :         /*      check the validity of the parameters.                  */
    5660             :         /* ----------------------------------------------------------- */
    5661           1 :         if (scale <= 0.0 || width <= 0 || height <= 0 || poGeorefExt == NULL || poPixPos == NULL ) {
    5662           0 :             msSetError(12, "Incorrect arguments", "mapscript::mapObj::zoomScale");
    5663           0 :             return MS_FAILURE;
    5664             :         }
    5665             : 
    5666             :         /* ----------------------------------------------------------- */
    5667             :         /*      check if the values passed are consistent min > max.   */
    5668             :         /* ----------------------------------------------------------- */
    5669           1 :         if (poGeorefExt->minx >= poGeorefExt->maxx) {
    5670           0 :             msSetError(12, "Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomScale()");
    5671           0 :             return MS_FAILURE;
    5672             :         }
    5673           1 :         if (poGeorefExt->miny >= poGeorefExt->maxy) {
    5674           0 :             msSetError(12, "Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomScale()");
    5675           0 :             return MS_FAILURE;
    5676             :         }
    5677             : 
    5678           1 :         if (bMaxExtSet == 1) {
    5679           1 :             if (poMaxGeorefExt->minx >= poMaxGeorefExt->maxx) {
    5680           0 :                 msSetError(12, "Max Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomScale()");
    5681           0 :                 return MS_FAILURE;
    5682             :             }
    5683           1 :             if (poMaxGeorefExt->miny >= poMaxGeorefExt->maxy) {
    5684           0 :                 msSetError(12,  "Max Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomScale()");
    5685             :             }
    5686             :         }
    5687             :    
    5688           1 :         dfDeltaX = poGeorefExt->maxx - poGeorefExt->minx;
    5689           1 :         dfDeltaY = poGeorefExt->maxy - poGeorefExt->miny;
    5690           1 :         dX = dfDeltaX/((double)width);
    5691           1 :         dY = dfDeltaY/((double)height);
    5692           1 :         dfGeoPosX = poGeorefExt->minx + dX * (double)poPixPos->x;
    5693           1 :         dfGeoPosY = poGeorefExt->maxy - dY * (double)poPixPos->y;
    5694             : 
    5695           1 :         if (self->gt.rotation_angle != 0) {
    5696           0 :             dfGeoPosX = self->gt.geotransform[0] + self->gt.geotransform[1] * (double)poPixPos->x + self->gt.geotransform[2] * (double)poPixPos->y;
    5697           0 :             dfGeoPosY = self->gt.geotransform[3] + self->gt.geotransform[4] * (double)poPixPos->x + self->gt.geotransform[5] * (double)poPixPos->y;
    5698             :         }
    5699             :         
    5700             :         /* ------------------------------------------------------------ */
    5701             :         /*  Calculate new extents based on the scale.                   */
    5702             :         /* ------------------------------------------------------------ */
    5703             : 
    5704             :         /* ============================================================ */
    5705             :         /*  make sure to take the smallest size because this is the one */
    5706             :         /*  that will be used to ajust the scale.                       */
    5707             :         /* ============================================================ */
    5708             : 
    5709           1 :         if (self->width <  self->height)
    5710             :             nTmp = self->width;
    5711             :         else
    5712             :             nTmp = self->height;
    5713             : 
    5714             :         /* To be consistent in swig mapscript and PHP mapscript, 
    5715             :            use the same function to calculate the delta extents. */
    5716           1 :         dfDeltaExt = GetDeltaExtentsUsingScale(scale, self->units, dfGeoPosY, nTmp, self->resolution);
    5717             : 
    5718           1 :         if (dfDeltaExt > 0.0) {
    5719           1 :             oNewGeorefExt.minx = dfGeoPosX - (dfDeltaExt/2);
    5720           1 :             oNewGeorefExt.miny = dfGeoPosY - (dfDeltaExt/2);
    5721           1 :             oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaExt/2);
    5722           1 :             oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaExt/2);
    5723             :         } else
    5724             :             return MS_FAILURE;
    5725             : 
    5726             :         /* ------------------------------------------------------------ */
    5727             :         /*   get current scale.                                         */
    5728             :         /* ------------------------------------------------------------ */
    5729           1 :         msCalculateScale(*poGeorefExt, self->units, self->width, self->height, self->resolution, &dfCurrentScale);
    5730             : 
    5731             :         /* ------------------------------------------------------------ *
    5732             :          *   if the min and max scale are set in the map file, we will  *
    5733             :          *   use them to test before zooming.                           *
    5734             :          *                                                              *
    5735             :          *   This function has the same effect as zoomin or zoom out.
    5736             :          *   If the current scale is > newscale we zoom in; else it is
    5737             :          *   a zoom out.
    5738             :          * ------------------------------------------------------------ */
    5739           1 :         msAdjustExtent(&oNewGeorefExt, self->width, self->height);
    5740           1 :         msCalculateScale(oNewGeorefExt, self->units, self->width, self->height, self->resolution, &dfNewScale);
    5741             : 
    5742           1 :         if (self->web.maxscaledenom > 0) {
    5743           0 :             if (dfCurrentScale < dfNewScale && dfNewScale >  self->web.maxscaledenom) {
    5744             :                 return MS_FAILURE;
    5745             :             }
    5746             :         }
    5747             : 
    5748             :         /* ============================================================ */
    5749             :         /* we do a special case for zoom in : we try to zoom as much as */
    5750             :         /* possible using the mincale set in the .map.                  */
    5751             :         /* ============================================================ */
    5752           1 :         if (self->web.minscaledenom > 0 && dfNewScale <  self->web.minscaledenom && dfCurrentScale > dfNewScale) {
    5753             :             /* To be consistent in swig mapscript and PHP mapscript, 
    5754             :                use the same function to calculate the delta extents. */
    5755           0 :             dfDeltaExt = GetDeltaExtentsUsingScale(scale, self->units, dfGeoPosY, nTmp, self->resolution);
    5756           0 :             if (dfDeltaExt > 0.0) {
    5757           0 :                 oNewGeorefExt.minx = dfGeoPosX - (dfDeltaExt/2);
    5758           0 :                 oNewGeorefExt.miny = dfGeoPosY - (dfDeltaExt/2);
    5759           0 :                 oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaExt/2);
    5760           0 :                 oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaExt/2);
    5761             :             } else
    5762             :                 return MS_FAILURE;
    5763             :         }
    5764             : 
    5765             :         /* ------------------------------------------------------------ */
    5766             :         /*  If the buffer is set, make sure that the extents do not go  */
    5767             :         /*  beyond the buffer.                                          */
    5768             :         /* ------------------------------------------------------------ */
    5769           1 :         if (bMaxExtSet) {
    5770           1 :             dfDeltaX = oNewGeorefExt.maxx - oNewGeorefExt.minx;
    5771           1 :             dfDeltaY = oNewGeorefExt.maxy - oNewGeorefExt.miny;
    5772             :         
    5773             :             /* Make sure Current georef extents is not bigger 
    5774             :              * than max extents */
    5775           1 :             if (dfDeltaX > (poMaxGeorefExt->maxx-poMaxGeorefExt->minx))
    5776             :                 dfDeltaX = poMaxGeorefExt->maxx-poMaxGeorefExt->minx;
    5777           1 :             if (dfDeltaY > (poMaxGeorefExt->maxy-poMaxGeorefExt->miny))
    5778             :                 dfDeltaY = poMaxGeorefExt->maxy-poMaxGeorefExt->miny;
    5779             : 
    5780           1 :             if (oNewGeorefExt.minx < poMaxGeorefExt->minx) {
    5781           1 :                 oNewGeorefExt.minx = poMaxGeorefExt->minx;
    5782           1 :                 oNewGeorefExt.maxx =  oNewGeorefExt.minx + dfDeltaX;
    5783             :             }
    5784           1 :             if (oNewGeorefExt.maxx > poMaxGeorefExt->maxx) {
    5785           0 :                 oNewGeorefExt.maxx = poMaxGeorefExt->maxx;
    5786           0 :                 oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
    5787             :             }
    5788           1 :             if (oNewGeorefExt.miny < poMaxGeorefExt->miny) {
    5789           1 :                 oNewGeorefExt.miny = poMaxGeorefExt->miny;
    5790           1 :                 oNewGeorefExt.maxy =  oNewGeorefExt.miny + dfDeltaY;
    5791             :             }
    5792           1 :             if (oNewGeorefExt.maxy > poMaxGeorefExt->maxy) {
    5793           0 :                 oNewGeorefExt.maxy = poMaxGeorefExt->maxy;
    5794           0 :                 oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
    5795             :             }
    5796             :         }
    5797             : 
    5798           1 :         self->extent.minx = oNewGeorefExt.minx;
    5799           1 :         self->extent.miny = oNewGeorefExt.miny;
    5800           1 :         self->extent.maxx = oNewGeorefExt.maxx;
    5801           1 :         self->extent.maxy = oNewGeorefExt.maxy;
    5802             :     
    5803           1 :         self->cellsize = msAdjustExtent(&(self->extent), self->width, self->height);    
    5804           1 :         dfDeltaX = self->extent.maxx - self->extent.minx;
    5805           1 :         dfDeltaY = self->extent.maxy - self->extent.miny; 
    5806             : 
    5807           1 :         if (bMaxExtSet) {
    5808           1 :             if (self->extent.minx < poMaxGeorefExt->minx) {
    5809           0 :                 self->extent.minx = poMaxGeorefExt->minx;
    5810           0 :                 self->extent.maxx = self->extent.minx + dfDeltaX;
    5811             :             }
    5812           1 :             if (self->extent.maxx > poMaxGeorefExt->maxx) {
    5813           0 :                 self->extent.maxx = poMaxGeorefExt->maxx;
    5814           0 :                 oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
    5815             :             }
    5816           1 :             if (self->extent.miny < poMaxGeorefExt->miny) {
    5817           0 :                 self->extent.miny = poMaxGeorefExt->miny;
    5818           0 :                 self->extent.maxy =  self->extent.miny + dfDeltaY;
    5819             :             }
    5820           1 :             if (self->extent.maxy > poMaxGeorefExt->maxy) {
    5821           0 :                 self->extent.maxy = poMaxGeorefExt->maxy;
    5822           0 :                 oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
    5823             :             }
    5824             :         }
    5825             : 
    5826           1 :         msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &(self->scaledenom));
    5827             : 
    5828           1 :         return MS_SUCCESS;
    5829             :     }
    5830           1 : SWIGINTERN PyObject *mapObj_getLayerOrder(struct mapObj *self){
    5831             :         int i;
    5832             :         PyObject *order;
    5833           1 :         order = PyTuple_New(self->numlayers);
    5834           1 :         for (i = 0; i < self->numlayers; i++) {
    5835           1 :             PyTuple_SetItem(order,i,PyInt_FromLong((long)self->layerorder[i]));
    5836             :         }
    5837           1 :         return order;
    5838             :     }
    5839           1 : SWIGINTERN int mapObj_setLayerOrder(struct mapObj *self,PyObject *order){
    5840             :         int i;
    5841           1 :         Py_ssize_t size = PyTuple_Size(order);
    5842           1 :         for (i = 0; i < size; i++) {
    5843           1 :             self->layerorder[i] = (int)PyInt_AsLong(PyTuple_GetItem(order, i));
    5844             :         }
    5845           1 :         return MS_SUCCESS;
    5846             :     }
    5847           1 : SWIGINTERN PyObject *mapObj_getSize(struct mapObj *self){
    5848             :         PyObject* output ;
    5849           1 :         output = PyTuple_New(2);
    5850           1 :         PyTuple_SetItem(output,0,PyInt_FromLong((long)self->width));
    5851           1 :         PyTuple_SetItem(output,1,PyInt_FromLong((long)self->height));
    5852           1 :         return output;
    5853             :     }
    5854           1 : SWIGINTERN rectObj *new_rectObj(double minx,double miny,double maxx,double maxy,int imageunits){
    5855             :         rectObj *rect;
    5856             :     
    5857           1 :         if (imageunits == 0)
    5858             :         { 
    5859           1 :             if (minx > maxx || miny > maxy)
    5860             :             {
    5861           1 :                 msSetError(34,
    5862             :                     "{ 'minx': %f , 'miny': %f , 'maxx': %f , 'maxy': %f }",
    5863             :                     "rectObj()", minx, miny, maxx, maxy);
    5864           1 :                 return NULL;
    5865             :             }
    5866             :         }
    5867             :         else 
    5868             :         {
    5869           1 :             if (minx > maxx || maxy > miny) 
    5870             :             {
    5871           1 :                 msSetError(34,
    5872             :                     "image (pixel/line) units { 'minx': %f , 'miny': %f , 'maxx': %f , 'maxy': %f }",
    5873             :                     "rectObj()", minx, miny, maxx, maxy);
    5874           1 :                 return NULL;
    5875             :             }
    5876             :         }
    5877             :     
    5878           1 :         rect = (rectObj *)calloc(1, sizeof(rectObj));
    5879           1 :         if (!rect)
    5880             :             return(NULL);
    5881             :     
    5882           1 :         rect->minx = minx;
    5883           1 :         rect->miny = miny;
    5884           1 :         rect->maxx = maxx;
    5885           1 :         rect->maxy = maxy;
    5886             : 
    5887           1 :         return(rect);
    5888             :     }
    5889             : SWIGINTERN void delete_rectObj(rectObj *self){
    5890           1 :         free(self);
    5891             :     }
    5892             : SWIGINTERN int rectObj_project(rectObj *self,projectionObj *projin,projectionObj *projout){
    5893           0 :         return msProjectRect(projin, projout, self);
    5894             :     }
    5895             : SWIGINTERN double rectObj_fit(rectObj *self,int width,int height){
    5896           0 :         return  msAdjustExtent(self, width, height);
    5897             :     }
    5898           0 : SWIGINTERN int rectObj_draw(rectObj *self,mapObj *map,layerObj *layer,imageObj *image,int classindex,char *text){
    5899             :         shapeObj shape;
    5900             :         int ret;
    5901             : 
    5902           0 :         msInitShape(&shape);
    5903           0 :         msRectToPolygon(*self, &shape);
    5904           0 :         shape.classindex = classindex;
    5905           0 :         if(text && layer->class[classindex]->numlabels > 0) {
    5906           0 :           shape.text = msStrdup(text);
    5907             :         }
    5908             :         
    5909           0 :         ret = msDrawShape(map, layer, &shape, image, -1, MS_DRAWMODE_FEATURES|MS_DRAWMODE_LABELS);
    5910             : 
    5911           0 :         msFreeShape(&shape);
    5912             :     
    5913           0 :         return ret;
    5914             :     }
    5915           0 : SWIGINTERN pointObj *rectObj_getCenter(rectObj *self){
    5916             :         pointObj *center;
    5917           0 :         center = (pointObj *)calloc(1, sizeof(pointObj));
    5918           0 :         if (!center) {
    5919           0 :             msSetError(2, "Failed to allocate memory for point", "getCenter()");
    5920           0 :             return NULL;
    5921             :         }
    5922           0 :         center->x = (self->minx + self->maxx)/2;
    5923           0 :         center->y = (self->miny + self->maxy)/2;
    5924             :         
    5925           0 :         return center;
    5926             :     }
    5927           1 : SWIGINTERN shapeObj *rectObj_toPolygon(rectObj *self){
    5928           1 :         lineObj line = {0,NULL};
    5929             :         shapeObj *shape;
    5930           1 :         shape = (shapeObj *)malloc(sizeof(shapeObj));
    5931           1 :         if (!shape)
    5932             :             return NULL;
    5933           1 :         msInitShape(shape);
    5934           1 :         shape->type = MS_SHAPE_POLYGON;
    5935             :   
    5936           1 :         line.point = (pointObj *)malloc(sizeof(pointObj)*5);
    5937           1 :         line.point[0].x = self->minx;
    5938           1 :         line.point[0].y = self->miny;
    5939           1 :         line.point[1].x = self->minx;
    5940           1 :         line.point[1].y = self->maxy;
    5941           1 :         line.point[2].x = self->maxx;
    5942           1 :         line.point[2].y = self->maxy;
    5943           1 :         line.point[3].x = self->maxx;
    5944           1 :         line.point[3].y = self->miny;
    5945           1 :         line.point[4].x = line.point[0].x;
    5946           1 :         line.point[4].y = line.point[0].y;
    5947             :   
    5948           1 :         line.numpoints = 5;
    5949             :   
    5950           1 :         msAddLine(shape, &line);
    5951           1 :         msComputeBounds(shape);
    5952             :         
    5953           1 :         free(line.point);
    5954             : 
    5955           1 :         return shape;
    5956             :     }
    5957           1 : SWIGINTERN char *rectObj_toString(rectObj *self){
    5958             :         char buffer[256];
    5959           1 :         char fmt[]="{ 'minx': %.16g , 'miny': %.16g , 'maxx': %.16g , 'maxy': %.16g }";
    5960           1 :         msRectToFormattedString(self, (char *) &fmt, (char *) &buffer, 256);
    5961           1 :         return msStrdup(buffer);
    5962             :     }
    5963             : SWIGINTERN pointObj *new_pointObj(double x,double y,double z,double m){
    5964             :         pointObj *p;
    5965           1 :         p = (pointObj *)calloc(1,sizeof(pointObj));
    5966           1 :         if (!p) return NULL;
    5967           1 :         p->x = x;
    5968           1 :         p->y = y;
    5969             : 
    5970             : 
    5971             : 
    5972             : 
    5973             :         return p;
    5974             :     }
    5975             : SWIGINTERN void delete_pointObj(pointObj *self){
    5976           1 :         free(self);
    5977             :     }
    5978             : SWIGINTERN int pointObj_project(pointObj *self,projectionObj *projin,projectionObj *projout){
    5979           1 :         return msProjectPoint(projin, projout, self);
    5980             :     }
    5981             : SWIGINTERN int pointObj_draw(pointObj *self,mapObj *map,layerObj *layer,imageObj *image,int classindex,char *text){
    5982           1 :         return msDrawPoint(map, layer, self, image, classindex, text);
    5983             :     }
    5984             : SWIGINTERN double pointObj_distanceToPoint(pointObj *self,pointObj *point){
    5985           0 :         return msDistancePointToPoint(self, point);
    5986             :     }
    5987             : SWIGINTERN double pointObj_distanceToSegment(pointObj *self,pointObj *a,pointObj *b){
    5988           0 :         return msDistancePointToSegment(self, a, b);
    5989             :     }
    5990             : SWIGINTERN double pointObj_distanceToShape(pointObj *self,shapeObj *shape){
    5991           0 :         return msDistancePointToShape(self, shape);
    5992             :     }
    5993             : SWIGINTERN int pointObj_setXY(pointObj *self,double x,double y,double m){
    5994           1 :         self->x = x;
    5995           1 :         self->y = y;
    5996             : 
    5997             : 
    5998             : 
    5999             : 
    6000             :         return MS_SUCCESS;
    6001             :     }
    6002             : SWIGINTERN int pointObj_setXYZ(pointObj *self,double x,double y,double z,double m){
    6003           1 :         self->x = x;
    6004           1 :         self->y = y;
    6005             : 
    6006             : 
    6007             : 
    6008             : 
    6009             :         return MS_SUCCESS;
    6010             :     }
    6011             : SWIGINTERN int pointObj_setXYZM(pointObj *self,double x,double y,double z,double m){
    6012           0 :         self->x = x;
    6013           0 :         self->y = y;
    6014             : 
    6015             : 
    6016             : 
    6017             : 
    6018             :         return MS_SUCCESS;
    6019             :     }
    6020           1 : SWIGINTERN char *pointObj_toString(pointObj *self){
    6021             :         char buffer[256];
    6022             :         const char *fmt;
    6023             : 
    6024             : 
    6025             : 
    6026             : 
    6027             : 
    6028             : 
    6029             : 
    6030             :         fmt = "{ 'x': %.16g, 'y': %.16g }";
    6031             : 
    6032             : 
    6033           1 :         msPointToFormattedString(self, fmt, (char *) &buffer, 256);
    6034           1 :         return msStrdup(buffer);
    6035             :     }
    6036           0 : SWIGINTERN shapeObj *pointObj_toShape(pointObj *self){
    6037             :       shapeObj *shape;
    6038             : 
    6039           0 :       shape = (shapeObj *) malloc(sizeof(shapeObj));
    6040           0 :       msInitShape(shape);
    6041             :     
    6042           0 :       shape->type = MS_SHAPE_POINT;
    6043           0 :       shape->line = (lineObj *) malloc(sizeof(lineObj));
    6044           0 :       shape->numlines = 1;
    6045           0 :       shape->line[0].point = (pointObj *) malloc(sizeof(pointObj));
    6046           0 :       shape->line[0].numpoints = 1;
    6047             : 
    6048           0 :       shape->line[0].point[0].x = self->x;
    6049           0 :       shape->line[0].point[0].y = self->y;
    6050             : 
    6051             : 
    6052             : 
    6053             : 
    6054             : 
    6055           0 :       return shape;
    6056             :     }
    6057             : SWIGINTERN lineObj *new_lineObj(void){
    6058             :         lineObj *line;
    6059             : 
    6060           1 :         line = (lineObj *)malloc(sizeof(lineObj));
    6061           1 :         if (!line)
    6062             :             return(NULL);
    6063             : 
    6064           1 :         line->numpoints=0;
    6065           1 :         line->point=NULL;
    6066             : 
    6067             :         return line;
    6068             :     }
    6069             : SWIGINTERN void delete_lineObj(lineObj *self){
    6070           1 :         free(self->point);
    6071           1 :         free(self);   
    6072             :     }
    6073             : SWIGINTERN int lineObj_project(lineObj *self,projectionObj *projin,projectionObj *projout){
    6074           0 :         return msProjectLine(projin, projout, self);
    6075             :     }
    6076             : SWIGINTERN pointObj *lineObj_get(lineObj *self,int i){
    6077           1 :         if (i<0 || i>=self->numpoints)
    6078             :             return NULL;
    6079             :         else
    6080           1 :             return &(self->point[i]);
    6081             :     }
    6082           1 : SWIGINTERN int lineObj_add(lineObj *self,pointObj *p){
    6083           1 :         if (self->numpoints == 0) { /* new */  
    6084           1 :         self->point = (pointObj *)malloc(sizeof(pointObj));
    6085           1 :         if (!self->point)
    6086             :             return MS_FAILURE;
    6087             :         } else { /* extend array */
    6088           1 :             self->point = (pointObj *)realloc(self->point, 
    6089           1 :                                       sizeof(pointObj)*(self->numpoints+1));
    6090           1 :         if (!self->point)
    6091             :             return MS_FAILURE;
    6092             :         }
    6093             : 
    6094           1 :         self->point[self->numpoints].x = p->x;
    6095           1 :         self->point[self->numpoints].y = p->y;
    6096           1 :         self->numpoints++;
    6097             : 
    6098             :         return MS_SUCCESS;
    6099             :     }
    6100             : SWIGINTERN int lineObj_set(lineObj *self,int i,pointObj *p){
    6101           0 :         if (i<0 || i>=self->numpoints)
    6102             :             return MS_FAILURE;
    6103             : 
    6104           0 :         self->point[i].x = p->x;
    6105           0 :         self->point[i].y = p->y;
    6106             :         return MS_SUCCESS;
    6107             :     }
    6108           1 : SWIGINTERN shapeObj *new_shapeObj(int type){
    6109             :         shapeObj *shape;
    6110             : 
    6111           1 :     shape = (shapeObj *)malloc(sizeof(shapeObj));
    6112           1 :         if (!shape)
    6113             :             return NULL;
    6114             : 
    6115           1 :         msInitShape(shape);
    6116           1 :         if(type >= 0) shape->type = type;
    6117             :         
    6118             :         return shape;
    6119             :     }
    6120             : SWIGINTERN void delete_shapeObj(shapeObj *self){
    6121           1 :         msFreeShape(self);
    6122           1 :         free(self);   
    6123             :     }
    6124             : SWIGINTERN shapeObj *shapeObj_fromWKT(char *wkt){
    6125             :     shapeObj *shape;
    6126             :         
    6127           1 :         if(!wkt) return NULL;
    6128             : 
    6129           1 :         shape = msShapeFromWKT(wkt);
    6130           1 :     if(!shape) return NULL;
    6131             : 
    6132             :     return shape;
    6133             :     }
    6134             : SWIGINTERN int shapeObj_project(shapeObj *self,projectionObj *projin,projectionObj *projout){
    6135           1 :         return msProjectShape(projin, projout, self);
    6136             :     }
    6137             : SWIGINTERN lineObj *shapeObj_get(shapeObj *self,int i){
    6138           1 :         if (i<0 || i>=self->numlines)
    6139             :             return NULL;
    6140             :         else
    6141           1 :             return &(self->line[i]);
    6142             :     }
    6143             : SWIGINTERN int shapeObj_add(shapeObj *self,lineObj *line){
    6144           1 :         return msAddLine(self, line);
    6145             :     }
    6146             : SWIGINTERN int shapeObj_draw(shapeObj *self,mapObj *map,layerObj *layer,imageObj *image){
    6147           0 :         return msDrawShape(map, layer, self, image, -1, MS_DRAWMODE_FEATURES|MS_DRAWMODE_LABELS);
    6148             :     }
    6149             : SWIGINTERN void shapeObj_setBounds(shapeObj *self){    
    6150           1 :         msComputeBounds(self);
    6151             :         return;
    6152             :     }
    6153           1 : SWIGINTERN shapeObj *shapeObj_clone(shapeObj *self){
    6154             :         shapeObj *shape;
    6155           1 :         shape = (shapeObj *)malloc(sizeof(shapeObj));
    6156           1 :         if (!shape)
    6157             :             return NULL;
    6158           1 :         msInitShape(shape);
    6159           1 :         shape->type = self->type;
    6160           1 :         msCopyShape(self, shape);
    6161           1 :         return shape;
    6162             :     }
    6163             : SWIGINTERN int shapeObj_copy(shapeObj *self,shapeObj *dest){
    6164           0 :         return(msCopyShape(self, dest));
    6165             :     }
    6166             : SWIGINTERN char *shapeObj_toWKT(shapeObj *self){
    6167           1 :         return msShapeToWKT(self);
    6168             :     }
    6169           0 : SWIGINTERN shapeObj *shapeObj_buffer(shapeObj *self,double width){ return msGEOSBuffer(self, width); }
    6170           0 : SWIGINTERN shapeObj *shapeObj_simplify(shapeObj *self,double tolerance){ return msGEOSSimplify(self, tolerance); }
    6171           0 : SWIGINTERN shapeObj *shapeObj_topologyPreservingSimplify(shapeObj *self,double tolerance){ return msGEOSTopologyPreservingSimplify(self, tolerance); }
    6172           0 : SWIGINTERN shapeObj *shapeObj_convexHull(shapeObj *self){ return msGEOSConvexHull(self); }
    6173           0 : SWIGINTERN shapeObj *shapeObj_boundary(shapeObj *self){ return msGEOSBoundary(self); }
    6174           0 : SWIGINTERN pointObj *shapeObj_getCentroid(shapeObj *self){ return msGEOSGetCentroid(self); }
    6175           0 : SWIGINTERN shapeObj *shapeObj_Union(shapeObj *self,shapeObj *shape){ return msGEOSUnion(self, shape); }
    6176           0 : SWIGINTERN shapeObj *shapeObj_intersection(shapeObj *self,shapeObj *shape){ return msGEOSIntersection(self, shape); }
    6177           0 : SWIGINTERN shapeObj *shapeObj_difference(shapeObj *self,shapeObj *shape){ return msGEOSDifference(self, shape); }
    6178           0 : SWIGINTERN shapeObj *shapeObj_symDifference(shapeObj *self,shapeObj *shape){ return msGEOSSymDifference(self, shape); }
    6179           0 : SWIGINTERN int shapeObj_contains__SWIG_0(shapeObj *self,shapeObj *shape){ return msGEOSContains(self, shape); }
    6180           0 : SWIGINTERN int shapeObj_overlaps(shapeObj *self,shapeObj *shape){ return msGEOSOverlaps(self, shape); }
    6181           0 : SWIGINTERN int shapeObj_within(shapeObj *self,shapeObj *shape){ return msGEOSWithin(self, shape); }
    6182           0 : SWIGINTERN int shapeObj_crosses(shapeObj *self,shapeObj *shape){ return msGEOSCrosses(self, shape); }
    6183           0 : SWIGINTERN int shapeObj_intersects(shapeObj *self,shapeObj *shape){ return msGEOSIntersects(self, shape); }
    6184           0 : SWIGINTERN int shapeObj_touches(shapeObj *self,shapeObj *shape){ return msGEOSTouches(self, shape); }
    6185           0 : SWIGINTERN int shapeObj_equals(shapeObj *self,shapeObj *shape){ return msGEOSEquals(self, shape); }
    6186           0 : SWIGINTERN int shapeObj_disjoint(shapeObj *self,shapeObj *shape){ return msGEOSDisjoint(self, shape); }
    6187           0 : SWIGINTERN double shapeObj_getArea(shapeObj *self){ return msGEOSArea(self); }
    6188           0 : SWIGINTERN double shapeObj_getLength(shapeObj *self){ return msGEOSLength(self); }
    6189             : SWIGINTERN char *shapeObj_getValue(shapeObj *self,int i){
    6190           1 :         if (i >= 0 && i < self->numvalues && self->values)
    6191           1 :             return (self->values[i]);
    6192             :         else
    6193             :             return NULL;
    6194             :     }
    6195             : SWIGINTERN int shapeObj_contains__SWIG_1(shapeObj *self,pointObj *point){
    6196           0 :         if (self->type == MS_SHAPE_POLYGON)
    6197           0 :             return msIntersectPointPolygon(point, self);
    6198             :         
    6199             :         return -1;
    6200             :     }
    6201             : SWIGINTERN double shapeObj_distanceToPoint(shapeObj *self,pointObj *point){
    6202           0 :         return msDistancePointToShape(point, self); /* should there be a GEOS version of this? */
    6203             :     }
    6204             : SWIGINTERN double shapeObj_distanceToShape(shapeObj *self,shapeObj *shape){
    6205           0 :         return msGEOSDistance(self, shape); /* note this calls msDistanceShapeToShape() if GEOS support is not present */
    6206             :     }
    6207           0 : SWIGINTERN pointObj *shapeObj_getLabelPoint(shapeObj *self){
    6208           0 :         pointObj *point = (pointObj *)calloc(1, sizeof(pointObj));
    6209           0 :         if (point == NULL) {
    6210           0 :             msSetError(2, "Failed to allocate memory for point", "labelPoint()");
    6211           0 :             return NULL;
    6212             :         }
    6213             : 
    6214           0 :         if(self->type == MS_SHAPE_POLYGON && msPolygonLabelPoint(self, point, -1) == MS_SUCCESS)
    6215             :             return point;
    6216             : 
    6217           0 :         free(point);
    6218           0 :         return NULL;
    6219             :     }
    6220           1 : SWIGINTERN int shapeObj_setValue(shapeObj *self,int i,char *value){
    6221           1 :         if (!self->values || !value)
    6222             :         {
    6223           0 :             msSetError(19, "Can't set value", "setValue()");
    6224             :             return MS_FAILURE;
    6225             :         }
    6226           1 :         if (i >= 0 && i < self->numvalues)
    6227             :         {
    6228           1 :             msFree(self->values[i]);
    6229           1 :             self->values[i] = msStrdup(value);
    6230           1 :             if (!self->values[i])
    6231             :             {
    6232             :                 return MS_FAILURE;
    6233             :             }
    6234             :             else return MS_SUCCESS;
    6235             :         }
    6236             :         else
    6237             :         {
    6238           0 :             msSetError(19, "Invalid value index", 
    6239             :                                   "setValue()");
    6240             :             return MS_FAILURE;
    6241             :         }
    6242             :     }
    6243           1 : SWIGINTERN void shapeObj_initValues(shapeObj *self,int numvalues){
    6244             :         int i;
    6245             :         
    6246           1 :         if(self->values) msFreeCharArray(self->values, self->numvalues);
    6247           1 :         self->values = NULL;
    6248           1 :         self->numvalues = 0;
    6249             :         
    6250             :         /* Allocate memory for the values */
    6251           1 :         if (numvalues > 0) {
    6252           1 :             if ((self->values = (char **)malloc(sizeof(char *)*numvalues)) == NULL) {
    6253           0 :                 msSetError(2, "Failed to allocate memory for values", "shapeObj()");
    6254             :                 return;
    6255             :             } else {
    6256           1 :                 for (i=0; i<numvalues; i++) self->values[i] = msStrdup("");
    6257             :             }
    6258           1 :             self->numvalues = numvalues;
    6259             :         }
    6260             :     }
    6261             : 
    6262             : SWIGINTERN size_t
    6263             : SWIG_strnlen(const char* s, size_t maxlen)
    6264             : {
    6265             :   const char *p;
    6266           0 :   for (p = s; maxlen-- && *p; p++)
    6267             :     ;
    6268           0 :   return p - s;
    6269             : }
    6270             : 
    6271             : SWIGINTERN struct errorObj *new_errorObj(void){    
    6272           0 :         return msGetErrorObj();
    6273             :     }
    6274             : SWIGINTERN void delete_errorObj(struct errorObj *self){}
    6275           0 : SWIGINTERN errorObj *errorObj_next(struct errorObj *self){
    6276             :         errorObj *ep;
    6277             : 
    6278           0 :         if (self == NULL || self->next == NULL) return NULL;
    6279             : 
    6280           0 :         ep = msGetErrorObj();
    6281           0 :         while (ep != self) {
    6282             :             /* We reached end of list of active errorObj and 
    6283             :                didn't find the errorObj... this is bad! */
    6284           0 :             if (ep->next == NULL) return NULL;
    6285             :             ep = ep->next;
    6286             :         }
    6287             :     
    6288           0 :         return ep->next;
    6289             :     }
    6290             : SWIGINTERN char *DBFInfo_getFieldName(DBFInfo *self,int iField){
    6291             :         static char pszFieldName[1000];
    6292             :         int pnWidth;
    6293             :         int pnDecimals;
    6294           1 :         msDBFGetFieldInfo(self, iField, &pszFieldName[0], &pnWidth, 
    6295             :                           &pnDecimals);
    6296             :         return pszFieldName;
    6297             :     }
    6298           1 : SWIGINTERN int DBFInfo_getFieldWidth(DBFInfo *self,int iField){
    6299             :         char pszFieldName[1000];
    6300             :         int pnWidth;
    6301             :         int pnDecimals;
    6302           1 :         msDBFGetFieldInfo(self, iField, &pszFieldName[0], &pnWidth,
    6303             :                           &pnDecimals);
    6304           1 :         return pnWidth;
    6305             :     }
    6306           1 : SWIGINTERN int DBFInfo_getFieldDecimals(DBFInfo *self,int iField){
    6307             :         char pszFieldName[1000];
    6308             :         int pnWidth;
    6309             :         int pnDecimals;
    6310           1 :         msDBFGetFieldInfo(self, iField, &pszFieldName[0], &pnWidth,
    6311             :                           &pnDecimals);
    6312           1 :         return pnDecimals;
    6313             :     }
    6314             : SWIGINTERN int DBFInfo_getFieldType(DBFInfo *self,int iField){
    6315           1 :         return msDBFGetFieldInfo(self, iField, NULL, NULL, NULL);
    6316             :     }
    6317           1 : SWIGINTERN shapefileObj *new_shapefileObj(char *filename,int type){    
    6318             :         shapefileObj *shapefile;
    6319             :         int status;
    6320             : 
    6321           1 :         shapefile = (shapefileObj *)malloc(sizeof(shapefileObj));
    6322           1 :         if (!shapefile)
    6323             :             return NULL;
    6324             : 
    6325           1 :         if (type == -1)
    6326           1 :             status = msShapefileOpen(shapefile, "rb", filename, 1);
    6327           1 :         else if (type == -2)
    6328           0 :             status = msShapefileOpen(shapefile, "rb+", filename, 1);
    6329             :         else
    6330           1 :             status = msShapefileCreate(shapefile, filename, type);
    6331             : 
    6332           1 :         if (status == -1) {
    6333           0 :             msShapefileClose(shapefile);
    6334           0 :             free(shapefile);
    6335           0 :             return NULL;
    6336             :         }
    6337             :  
    6338             :         return(shapefile);
    6339             :     }
    6340             : SWIGINTERN void delete_shapefileObj(shapefileObj *self){
    6341           1 :         msShapefileClose(self);
    6342           1 :         free(self);  
    6343             :     }
    6344           1 : SWIGINTERN int shapefileObj_get(shapefileObj *self,int i,shapeObj *shape){
    6345           1 :         if (i<0 || i>=self->numshapes)
    6346             :             return MS_FAILURE;
    6347             : 
    6348           1 :         msFreeShape(shape); /* frees all lines and points before re-filling */
    6349           1 :         msSHPReadShape(self->hSHP, i, shape);
    6350             : 
    6351             :         return MS_SUCCESS;
    6352             :     }
    6353           0 : SWIGINTERN shapeObj *shapefileObj_getShape(shapefileObj *self,int i){
    6354             :         shapeObj *shape;
    6355           0 :         shape = (shapeObj *)malloc(sizeof(shapeObj));
    6356           0 :         if (!shape)
    6357             :             return NULL;
    6358           0 :         msInitShape(shape);
    6359           0 :         shape->type = self->type;
    6360           0 :         msSHPReadShape(self->hSHP, i, shape);
    6361             :         return shape;
    6362             : 
    6363             :     }
    6364             : SWIGINTERN int shapefileObj_getPoint(shapefileObj *self,int i,pointObj *point){
    6365           0 :         if (i<0 || i>=self->numshapes)
    6366             :             return MS_FAILURE;
    6367             : 
    6368           0 :         msSHPReadPoint(self->hSHP, i, point);
    6369             :         return MS_SUCCESS;
    6370             :     }
    6371           0 : SWIGINTERN int shapefileObj_getTransformed(shapefileObj *self,mapObj *map,int i,shapeObj *shape){
    6372           0 :         if (i<0 || i>=self->numshapes)
    6373             :             return MS_FAILURE;
    6374             : 
    6375           0 :         msFreeShape(shape); /* frees all lines and points before re-filling */
    6376           0 :         msSHPReadShape(self->hSHP, i, shape);
    6377           0 :         msTransformShapeSimplify(shape, map->extent, map->cellsize);
    6378             : 
    6379             :         return MS_SUCCESS;
    6380             :     }
    6381             : SWIGINTERN void shapefileObj_getExtent(shapefileObj *self,int i,rectObj *rect){
    6382           0 :         msSHPReadBounds(self->hSHP, i, rect);
    6383             :     }
    6384           1 : SWIGINTERN int shapefileObj_add(shapefileObj *self,shapeObj *shape){
    6385             :         /* Trap NULL or empty shapes -- bug 1201 */
    6386           1 :         if (!shape) 
    6387             :         {
    6388           0 :             msSetError(19, "Can't add NULL shape", "shapefileObj::add");
    6389             :             return MS_FAILURE;
    6390             :         }
    6391           1 :         else if (!shape->line)
    6392             :         {
    6393           1 :             msSetError(19, "Can't add empty shape", "shapefileObj::add");
    6394             :             return MS_FAILURE;
    6395             :         }
    6396             : 
    6397           0 :         return msSHPWriteShape(self->hSHP, shape);
    6398             :     }
    6399             : SWIGINTERN int shapefileObj_addPoint(shapefileObj *self,pointObj *point){    
    6400           0 :         return msSHPWritePoint(self->hSHP, point);
    6401             :     }
    6402             : SWIGINTERN DBFInfo *shapefileObj_getDBF(shapefileObj *self){
    6403             :         return self->hDBF;
    6404             :     }
    6405           1 : SWIGINTERN projectionObj *new_projectionObj(char *proj4){
    6406             :         int status;
    6407             :         projectionObj *proj=NULL;
    6408             : 
    6409           1 :         proj = (projectionObj *)malloc(sizeof(projectionObj));
    6410           1 :         if (!proj) return NULL;
    6411           1 :         msInitProjection(proj);
    6412             : 
    6413           1 :         status = msLoadProjectionString(proj, proj4);
    6414           1 :         if (status == -1) {
    6415           0 :             msFreeProjection(proj);
    6416           0 :             free(proj);
    6417           0 :             return NULL;
    6418             :         }
    6419             : 
    6420             :         return proj;
    6421             :     }
    6422             : SWIGINTERN void delete_projectionObj(projectionObj *self){
    6423           1 :         msFreeProjection(self);
    6424           1 :         free(self);
    6425             :     }
    6426             : SWIGINTERN int projectionObj_setWKTProjection(projectionObj *self,char *wkt){
    6427             :         /* no debug output here */
    6428           0 :         return msOGCWKT2ProjectionObj(wkt, self, 0);
    6429             :     }
    6430             : SWIGINTERN int projectionObj_getUnits(projectionObj *self){
    6431           1 :       return GetMapserverUnitUsingProj(self);
    6432             :     }
    6433           1 : SWIGINTERN colorObj *new_colorObj(int red,int green,int blue,int alpha){
    6434             :         colorObj *color;
    6435             :         
    6436             :         /* Check colors */
    6437           1 :         if (red > 255 || green > 255 || blue > 255 || alpha>255 ||
    6438           1 :             red<-1 || green<-1 || blue<-1 || alpha<0 ) {
    6439           0 :             msSetError(12, "Invalid color", "colorObj()");
    6440           0 :             return NULL;
    6441             :         }
    6442             :     
    6443           1 :         color = (colorObj *)calloc(1, sizeof(colorObj));
    6444           1 :         if (!color)
    6445             :             return(NULL);
    6446             :     
    6447           1 :         MS_INIT_COLOR(*color, red, green, blue, alpha);
    6448             : 
    6449           1 :         return(color);
    6450             :     }
    6451             : SWIGINTERN void delete_colorObj(colorObj *self){
    6452           1 :         free(self);
    6453             :     }
    6454           1 : SWIGINTERN int colorObj_setRGB(colorObj *self,int red,int green,int blue,int alpha){
    6455             :         /* Check colors */
    6456           1 :         if (red > 255 || green > 255 || blue > 255 || alpha > 255) {
    6457           0 :             msSetError(12, "Invalid color index.", "setRGB()");
    6458           0 :             return MS_FAILURE;
    6459             :         }
    6460             :     
    6461           1 :         MS_INIT_COLOR(*self, red, green, blue, alpha);
    6462           1 :         return MS_SUCCESS;
    6463             :     }
    6464           1 : SWIGINTERN int colorObj_setHex(colorObj *self,char *psHexColor){
    6465             :         int red, green, blue, alpha = 255;
    6466           1 :         if (psHexColor && (strlen(psHexColor) == 7 || strlen(psHexColor) == 9) && psHexColor[0] == '#') {
    6467           1 :             red = msHexToInt(psHexColor+1);
    6468           1 :             green = msHexToInt(psHexColor+3);
    6469           1 :             blue= msHexToInt(psHexColor+5);
    6470           1 :             if (strlen(psHexColor) == 9) {
    6471           1 :                 alpha = msHexToInt(psHexColor+7);
    6472             :             }
    6473           1 :             if (red > 255 || green > 255 || blue > 255 || alpha > 255) {
    6474           1 :                 msSetError(12, "Invalid color index.", "setHex()");
    6475           1 :                 return MS_FAILURE;
    6476             :             }
    6477             : 
    6478           1 :             MS_INIT_COLOR(*self, red, green, blue, alpha);
    6479           1 :             return MS_SUCCESS;
    6480             :         }
    6481             :         else {
    6482           0 :             msSetError(12, "Invalid hex color.", "setHex()");
    6483           0 :             return MS_FAILURE;
    6484             :         }
    6485             :     }
    6486           1 : SWIGINTERN char *colorObj_toHex(colorObj *self){
    6487             :         char *hexcolor;
    6488             : 
    6489           1 :         if (!self) 
    6490             :         {
    6491           0 :             msSetError(12, "Can't express NULL color as hex",
    6492             :                        "toHex()");
    6493           0 :             return NULL;
    6494             :         }
    6495           1 :         if (self->red < 0 || self->green < 0 || self->blue < 0) 
    6496             :         {
    6497           1 :             msSetError(12, "Can't express invalid color as hex",
    6498             :                        "toHex()");
    6499           1 :             return NULL;
    6500             :         }
    6501           1 :         if (self->alpha == 255) {
    6502           1 :           hexcolor = msSmallMalloc(8);
    6503           1 :           snprintf(hexcolor, 8, "#%02x%02x%02x",
    6504             :                    self->red, self->green, self->blue);
    6505           0 :         } else if (self->alpha >= 0) {
    6506           0 :           hexcolor = msSmallMalloc(10);
    6507           0 :           snprintf(hexcolor, 10, "#%02x%02x%02x%02x",
    6508             :                    self->red, self->green, self->blue, self->alpha);
    6509             :         } else {
    6510           0 :            msSetError(12, "Can't express color with invalid alpha as hex",
    6511             :                       "toHex()");
    6512           0 :            return NULL;
    6513             :         }
    6514             :         return hexcolor;
    6515             :     }
    6516           1 : SWIGINTERN struct symbolObj *new_symbolObj(char *symbolname,char const *imagefile){
    6517             :         symbolObj *symbol;
    6518           1 :         symbol = (symbolObj *) malloc(sizeof(symbolObj));
    6519           1 :         initSymbol(symbol);
    6520           1 :         symbol->name = msStrdup(symbolname);
    6521           1 :         if (imagefile) {
    6522           1 :             msLoadImageSymbol(symbol, imagefile);
    6523             :         }
    6524           1 :         return symbol;
    6525             :     }
    6526           1 : SWIGINTERN void delete_symbolObj(struct symbolObj *self){
    6527           1 :         if (self) {
    6528           1 :             if (msFreeSymbol(self)==MS_SUCCESS) {
    6529           1 :                 free(self);
    6530             :                 self=NULL;
    6531             :             }
    6532             :         }
    6533           1 :     }
    6534             : SWIGINTERN int symbolObj_setImagepath(struct symbolObj *self,char const *imagefile){
    6535           1 :         return msLoadImageSymbol(self, imagefile);
    6536             :     }
    6537             : SWIGINTERN int symbolObj_setPoints(struct symbolObj *self,lineObj *line){
    6538             :         int i;
    6539           1 :     self->sizex = 0;
    6540           1 :     self->sizey = 0;
    6541           1 :         for (i=0; i<line->numpoints; i++) {
    6542           1 :             MS_COPYPOINT(&(self->points[i]), &(line->point[i]));
    6543           1 :         self->sizex = MS_MAX(self->sizex, self->points[i].x);
    6544           1 :         self->sizey = MS_MAX(self->sizey, self->points[i].y);
    6545             :         }
    6546           1 :         self->numpoints = line->numpoints;
    6547             :         return self->numpoints;
    6548             :     }
    6549           1 : SWIGINTERN lineObj *symbolObj_getPoints(struct symbolObj *self){
    6550             :         int i;
    6551             :         lineObj *line;
    6552           1 :         line = (lineObj *) malloc(sizeof(lineObj));
    6553           1 :         line->point = (pointObj *) malloc(sizeof(pointObj)*(self->numpoints));
    6554           1 :         for (i=0; i<self->numpoints; i++) {
    6555           1 :             line->point[i].x = self->points[i].x;
    6556           1 :             line->point[i].y = self->points[i].y;
    6557             :         }
    6558           1 :         line->numpoints = self->numpoints;
    6559           1 :         return line;
    6560             :     }
    6561           1 : SWIGINTERN imageObj *symbolObj_getImage(struct symbolObj *self,outputFormatObj *input_format){
    6562             :         imageObj *image = NULL;
    6563             :         outputFormatObj *format = NULL;
    6564             :         rendererVTableObj *renderer = NULL;
    6565             : 
    6566           1 :         if (input_format)
    6567             :         {
    6568             :             format = input_format;
    6569             :         }
    6570             :         else 
    6571             :         {
    6572           0 :             format = msCreateDefaultOutputFormat(NULL, "AGG/PNG", "aggpng");
    6573           0 :             if (format)
    6574           0 :                 msInitializeRendererVTable(format);
    6575             :         }
    6576             :         
    6577           1 :         if (format == NULL) 
    6578             :         {
    6579           0 :             msSetError(15, "Could not create output format",
    6580             :                        "getImage()");
    6581           0 :             return NULL;
    6582             :         }
    6583             : 
    6584           1 :         renderer = format->vtable;
    6585           1 :         msPreloadImageSymbol(renderer, self);
    6586           1 :         if (self->pixmap_buffer) 
    6587             :         {
    6588           1 :             image = msImageCreate(self->pixmap_buffer->width, self->pixmap_buffer->height, format, NULL, NULL,
    6589             :                                   MS_DEFAULT_RESOLUTION, MS_DEFAULT_RESOLUTION, NULL);
    6590           1 :             if(!image) {
    6591           0 :               msSetError(15, "Could not create image",
    6592             :                        "getImage()");
    6593           0 :               return NULL;
    6594             :             }
    6595           1 :             if(MS_SUCCESS != renderer->mergeRasterBuffer(image, self->pixmap_buffer, 1.0, 0, 0, 0, 0,
    6596           1 :                                         self->pixmap_buffer->width, self->pixmap_buffer->height)) {
    6597           0 :               msSetError(15, "Could not merge symbol image",
    6598             :                        "getImage()");
    6599           0 :               msFreeImage(image);
    6600           0 :               return NULL;
    6601             :             }
    6602             :         }
    6603             : 
    6604             :         return image;
    6605             :     }
    6606           0 : SWIGINTERN int symbolObj_setImage(struct symbolObj *self,imageObj *image){
    6607             :         rendererVTableObj *renderer = NULL;
    6608             :         
    6609           0 :         renderer = image->format->vtable;
    6610             :         
    6611           0 :         if (self->pixmap_buffer) {
    6612           0 :             msFreeRasterBuffer(self->pixmap_buffer);
    6613           0 :             free(self->pixmap_buffer);
    6614             :         }
    6615             :         
    6616           0 :         self->pixmap_buffer = (rasterBufferObj*)malloc(sizeof(rasterBufferObj));
    6617           0 :         if (!self->pixmap_buffer) {
    6618           0 :             msSetError(2, NULL, "setImage()");
    6619             :             return MS_FAILURE;
    6620             :         }
    6621           0 :         self->type = MS_SYMBOL_PIXMAP;
    6622           0 :         return renderer->getRasterBufferCopy(image, self->pixmap_buffer);
    6623             :     }
    6624             : SWIGINTERN hashTableObj *new_hashTableObj(void){
    6625             : 
    6626           1 :         return msCreateHashTable();
    6627             :     }
    6628             : SWIGINTERN void delete_hashTableObj(hashTableObj *self){
    6629           1 :         msFreeHashTable(self);
    6630             :     }
    6631             : SWIGINTERN int hashTableObj_set(hashTableObj *self,char *key,char *value){
    6632           1 :         if (msInsertHashTable(self, key, value) == NULL) {
    6633             :             return MS_FAILURE;
    6634             :         }
    6635             :         return MS_SUCCESS;
    6636             :     }
    6637           1 : SWIGINTERN char *hashTableObj_get(hashTableObj *self,char *key,char *default_value){
    6638             :         char *value = NULL;
    6639           1 :         if (!key) {
    6640           0 :             msSetError(16, "NULL key", "get");
    6641             :         }
    6642             :      
    6643           1 :         value = (char *) msLookupHashTable(self, key);
    6644           1 :         if (!value) {
    6645             :             return default_value;
    6646             :         }
    6647           1 :         return value;
    6648             :     }
    6649             : SWIGINTERN int hashTableObj_remove(hashTableObj *self,char *key){
    6650           1 :         return msRemoveHashTable(self, key);
    6651             :     }
    6652             : SWIGINTERN void hashTableObj_clear(hashTableObj *self){
    6653           1 :         msFreeHashItems(self);
    6654           1 :         initHashTable(self);
    6655             :     }
    6656             : SWIGINTERN char const *hashTableObj_nextKey(hashTableObj *self,char *prevkey){
    6657           1 :         return msNextKeyFromHashTable(self, (const char *) prevkey);
    6658             :     }
    6659             : 
    6660           1 : static char *msGetEnvURL( const char *key, void *thread_context )
    6661             : {
    6662           1 :     if( strcmp(key,"REQUEST_METHOD") == 0 )
    6663             :         return "GET";
    6664             : 
    6665           1 :     if( strcmp(key,"QUERY_STRING") == 0 )
    6666             :         return (char *) thread_context;
    6667             : 
    6668           1 :     return NULL;
    6669             : }
    6670             : 
    6671           1 : SWIGINTERN cgiRequestObj *new_cgiRequestObj(void){
    6672             :         cgiRequestObj *request;
    6673             : 
    6674           1 :         request = msAllocCgiObj();
    6675           1 :         if (!request) {
    6676           0 :             msSetError(13, "Failed to initialize object","OWSRequest()");
    6677           0 :             return NULL;
    6678             :         }
    6679             :         
    6680             :         return request;
    6681             :     }
    6682             : SWIGINTERN void delete_cgiRequestObj(cgiRequestObj *self){
    6683           1 :         msFreeCgiObj(self);
    6684             :     }
    6685             : SWIGINTERN int cgiRequestObj_loadParams(cgiRequestObj *self){
    6686           0 :         self->NumParams = loadParams( self, NULL, NULL, 0, NULL);
    6687             :         return self->NumParams;
    6688             :     }
    6689             : SWIGINTERN int cgiRequestObj_loadParamsFromURL(cgiRequestObj *self,char const *url){
    6690           1 :         self->NumParams = loadParams( self, msGetEnvURL, NULL, 0, (void*)url );
    6691             :         return self->NumParams;
    6692             :     }
    6693           1 : SWIGINTERN void cgiRequestObj_setParameter(cgiRequestObj *self,char *name,char *value){
    6694             :         int i;
    6695             :         
    6696           1 :         if (self->NumParams == 100) {
    6697           0 :             msSetError(31, "Maximum number of items, %d, has been reached", "setItem()", 100);
    6698             :         }
    6699             :         
    6700           1 :         for (i=0; i<self->NumParams; i++) {
    6701           1 :             if (strcasecmp(self->ParamNames[i], name) == 0) {
    6702           1 :                 free(self->ParamValues[i]);
    6703           1 :                 self->ParamValues[i] = msStrdup(value);
    6704           1 :                 break;
    6705             :             }
    6706             :         }
    6707           1 :         if (i == self->NumParams) {
    6708           1 :             self->ParamNames[self->NumParams] = msStrdup(name);
    6709           1 :             self->ParamValues[self->NumParams] = msStrdup(value);
    6710           1 :             self->NumParams++;
    6711             :         }
    6712           1 :     }
    6713           0 : SWIGINTERN void cgiRequestObj_addParameter(cgiRequestObj *self,char *name,char *value){
    6714           0 :         if (self->NumParams == 100) {
    6715           0 :             msSetError(31, "Maximum number of items, %d, has been reached", "addParameter()", 100);
    6716             :         }
    6717           0 :         self->ParamNames[self->NumParams] = msStrdup(name);
    6718           0 :         self->ParamValues[self->NumParams] = msStrdup(value);
    6719           0 :         self->NumParams++;
    6720           0 :     }
    6721           1 : SWIGINTERN char *cgiRequestObj_getName(cgiRequestObj *self,int index){
    6722           1 :         if (index < 0 || index >= self->NumParams) {
    6723           0 :             msSetError(31, "Invalid index, valid range is [0, %d]", "getName()", self->NumParams-1);
    6724             :             return NULL;
    6725             :         }
    6726           1 :         return self->ParamNames[index];
    6727             :     }
    6728           1 : SWIGINTERN char *cgiRequestObj_getValue(cgiRequestObj *self,int index){
    6729           1 :         if (index < 0 || index >= self->NumParams) {
    6730           0 :             msSetError(31, "Invalid index, valid range is [0, %d]", "getValue()", self->NumParams-1);
    6731             :             return NULL;
    6732             :         }
    6733           1 :         return self->ParamValues[index];
    6734             :     }
    6735           1 : SWIGINTERN char *cgiRequestObj_getValueByName(cgiRequestObj *self,char const *name){
    6736             :         int i;
    6737           1 :         for (i=0; i<self->NumParams; i++) {
    6738           1 :             if (strcasecmp(self->ParamNames[i], name) == 0) {
    6739           1 :                 return self->ParamValues[i];
    6740             :             }
    6741             :         }
    6742             :         return NULL;
    6743             :     }
    6744             : 
    6745             : 
    6746           0 : const char *msIO_getStdoutBufferString() {
    6747           0 :     msIOContext *ctx = msIO_getHandler( (FILE *) "stdout" );
    6748             :     msIOBuffer  *buf;
    6749             : 
    6750           0 :     if( ctx == NULL || ctx->write_channel == MS_FALSE 
    6751           0 :         || strcmp(ctx->label,"buffer") != 0 )
    6752             :     {
    6753           0 :         msSetError( MS_MISCERR, "Can't identify msIO buffer.",
    6754             :                     "msIO_getStdoutBufferString" );
    6755           0 :         return "";
    6756             :     }
    6757             : 
    6758           0 :     buf = (msIOBuffer *) ctx->cbData;
    6759             : 
    6760             :     /* write one zero byte and backtrack if it isn't already there */
    6761           0 :     if( buf->data_len == 0 || buf->data[buf->data_offset] != '\0' ) {
    6762           0 :         msIO_bufferWrite( buf, "", 1 );
    6763           0 :         buf->data_offset--;
    6764             :     }
    6765             : 
    6766           0 :     return (const char *) (buf->data);
    6767             : }
    6768             : 
    6769           1 : gdBuffer msIO_getStdoutBufferBytes() {
    6770           1 :     msIOContext *ctx = msIO_getHandler( (FILE *) "stdout" );
    6771             :     msIOBuffer  *buf;
    6772             :     gdBuffer     gdBuf;
    6773             : 
    6774           1 :     if( ctx == NULL || ctx->write_channel == MS_FALSE 
    6775           1 :         || strcmp(ctx->label,"buffer") != 0 )
    6776             :     {
    6777           0 :         msSetError( MS_MISCERR, "Can't identify msIO buffer.",
    6778             :                         "msIO_getStdoutBufferString" );
    6779             :         gdBuf.data = (unsigned char*)"";
    6780             :         gdBuf.size = 0;
    6781             :         gdBuf.owns_data = MS_FALSE;
    6782           0 :         return gdBuf;
    6783             :     }
    6784             : 
    6785           1 :     buf = (msIOBuffer *) ctx->cbData;
    6786             : 
    6787           1 :     gdBuf.data = buf->data;
    6788           1 :     gdBuf.size = buf->data_offset;
    6789             :     gdBuf.owns_data = MS_TRUE;
    6790             : 
    6791             :     /* we are seizing ownership of the buffer contents */
    6792           1 :     buf->data_offset = 0;
    6793           1 :     buf->data_len = 0;
    6794           1 :     buf->data = NULL;
    6795             : 
    6796           1 :     return gdBuf;
    6797             : }
    6798             : 
    6799             : 
    6800             : #ifdef __cplusplus
    6801             : extern "C" {
    6802             : #endif
    6803           0 : SWIGINTERN PyObject *_wrap_new_intarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6804             :   PyObject *resultobj = 0;
    6805             :   size_t arg1 ;
    6806             :   size_t val1 ;
    6807             :   int ecode1 = 0 ;
    6808           0 :   PyObject * obj0 = 0 ;
    6809             :   intarray *result = 0 ;
    6810             :   
    6811           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_intarray",&obj0)) SWIG_fail;
    6812           0 :   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
    6813           0 :   if (!SWIG_IsOK(ecode1)) {
    6814           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intarray" "', argument " "1"" of type '" "size_t""'");
    6815             :   } 
    6816             :   arg1 = (size_t)(val1);
    6817             :   result = (intarray *)new_intarray(arg1);
    6818           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intarray, SWIG_POINTER_NEW |  0 );
    6819           0 :   return resultobj;
    6820           0 : fail:
    6821             :   return NULL;
    6822             : }
    6823             : 
    6824             : 
    6825           0 : SWIGINTERN PyObject *_wrap_delete_intarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6826             :   PyObject *resultobj = 0;
    6827             :   intarray *arg1 = (intarray *) 0 ;
    6828           0 :   void *argp1 = 0 ;
    6829             :   int res1 = 0 ;
    6830           0 :   PyObject * obj0 = 0 ;
    6831             :   
    6832           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_intarray",&obj0)) SWIG_fail;
    6833           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, SWIG_POINTER_DISOWN |  0 );
    6834           0 :   if (!SWIG_IsOK(res1)) {
    6835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intarray" "', argument " "1"" of type '" "intarray *""'"); 
    6836             :   }
    6837           0 :   arg1 = (intarray *)(argp1);
    6838             :   delete_intarray(arg1);
    6839             :   resultobj = SWIG_Py_Void();
    6840           0 :   return resultobj;
    6841           0 : fail:
    6842             :   return NULL;
    6843             : }
    6844             : 
    6845             : 
    6846           0 : SWIGINTERN PyObject *_wrap_intarray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6847             :   PyObject *resultobj = 0;
    6848             :   intarray *arg1 = (intarray *) 0 ;
    6849             :   size_t arg2 ;
    6850           0 :   void *argp1 = 0 ;
    6851             :   int res1 = 0 ;
    6852             :   size_t val2 ;
    6853             :   int ecode2 = 0 ;
    6854           0 :   PyObject * obj0 = 0 ;
    6855           0 :   PyObject * obj1 = 0 ;
    6856             :   int result;
    6857             :   
    6858           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:intarray___getitem__",&obj0,&obj1)) SWIG_fail;
    6859           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, 0 |  0 );
    6860           0 :   if (!SWIG_IsOK(res1)) {
    6861           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray___getitem__" "', argument " "1"" of type '" "intarray *""'"); 
    6862             :   }
    6863           0 :   arg1 = (intarray *)(argp1);
    6864           0 :   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    6865           0 :   if (!SWIG_IsOK(ecode2)) {
    6866           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intarray___getitem__" "', argument " "2"" of type '" "size_t""'");
    6867             :   } 
    6868             :   arg2 = (size_t)(val2);
    6869             :   result = (int)intarray___getitem__(arg1,arg2);
    6870             :   resultobj = SWIG_From_int((int)(result));
    6871           0 :   return resultobj;
    6872           0 : fail:
    6873             :   return NULL;
    6874             : }
    6875             : 
    6876             : 
    6877           0 : SWIGINTERN PyObject *_wrap_intarray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6878             :   PyObject *resultobj = 0;
    6879             :   intarray *arg1 = (intarray *) 0 ;
    6880             :   size_t arg2 ;
    6881             :   int arg3 ;
    6882           0 :   void *argp1 = 0 ;
    6883             :   int res1 = 0 ;
    6884             :   size_t val2 ;
    6885             :   int ecode2 = 0 ;
    6886             :   int val3 ;
    6887             :   int ecode3 = 0 ;
    6888           0 :   PyObject * obj0 = 0 ;
    6889           0 :   PyObject * obj1 = 0 ;
    6890           0 :   PyObject * obj2 = 0 ;
    6891             :   
    6892           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:intarray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
    6893           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, 0 |  0 );
    6894           0 :   if (!SWIG_IsOK(res1)) {
    6895           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray___setitem__" "', argument " "1"" of type '" "intarray *""'"); 
    6896             :   }
    6897           0 :   arg1 = (intarray *)(argp1);
    6898           0 :   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    6899           0 :   if (!SWIG_IsOK(ecode2)) {
    6900           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intarray___setitem__" "', argument " "2"" of type '" "size_t""'");
    6901             :   } 
    6902             :   arg2 = (size_t)(val2);
    6903           0 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
    6904           0 :   if (!SWIG_IsOK(ecode3)) {
    6905           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intarray___setitem__" "', argument " "3"" of type '" "int""'");
    6906             :   } 
    6907             :   arg3 = (int)(val3);
    6908             :   intarray___setitem__(arg1,arg2,arg3);
    6909             :   resultobj = SWIG_Py_Void();
    6910           0 :   return resultobj;
    6911           0 : fail:
    6912             :   return NULL;
    6913             : }
    6914             : 
    6915             : 
    6916           0 : SWIGINTERN PyObject *_wrap_intarray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6917             :   PyObject *resultobj = 0;
    6918             :   intarray *arg1 = (intarray *) 0 ;
    6919           0 :   void *argp1 = 0 ;
    6920             :   int res1 = 0 ;
    6921           0 :   PyObject * obj0 = 0 ;
    6922             :   int *result = 0 ;
    6923             :   
    6924           0 :   if (!PyArg_ParseTuple(args,(char *)"O:intarray_cast",&obj0)) SWIG_fail;
    6925           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, 0 |  0 );
    6926           0 :   if (!SWIG_IsOK(res1)) {
    6927           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray_cast" "', argument " "1"" of type '" "intarray *""'"); 
    6928             :   }
    6929           0 :   arg1 = (intarray *)(argp1);
    6930             :   result = (int *)intarray_cast(arg1);
    6931           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
    6932           0 :   return resultobj;
    6933           0 : fail:
    6934             :   return NULL;
    6935             : }
    6936             : 
    6937             : 
    6938           0 : SWIGINTERN PyObject *_wrap_intarray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6939             :   PyObject *resultobj = 0;
    6940             :   int *arg1 = (int *) 0 ;
    6941           0 :   void *argp1 = 0 ;
    6942             :   int res1 = 0 ;
    6943           0 :   PyObject * obj0 = 0 ;
    6944             :   intarray *result = 0 ;
    6945             :   
    6946           0 :   if (!PyArg_ParseTuple(args,(char *)"O:intarray_frompointer",&obj0)) SWIG_fail;
    6947           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
    6948           0 :   if (!SWIG_IsOK(res1)) {
    6949           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray_frompointer" "', argument " "1"" of type '" "int *""'"); 
    6950             :   }
    6951           0 :   arg1 = (int *)(argp1);
    6952             :   result = (intarray *)intarray_frompointer(arg1);
    6953           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intarray, 0 |  0 );
    6954           0 :   return resultobj;
    6955           0 : fail:
    6956             :   return NULL;
    6957             : }
    6958             : 
    6959             : 
    6960           1 : SWIGINTERN PyObject *intarray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6961             :   PyObject *obj;
    6962           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    6963           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_intarray, SWIG_NewClientData(obj));
    6964           1 :   return SWIG_Py_Void();
    6965             : }
    6966             : 
    6967           0 : SWIGINTERN PyObject *_wrap_CompositingFilter_filter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6968             :   PyObject *resultobj = 0;
    6969             :   struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
    6970             :   char *arg2 = (char *) 0 ;
    6971           0 :   void *argp1 = 0 ;
    6972             :   int res1 = 0 ;
    6973             :   int res2 ;
    6974           0 :   char *buf2 = 0 ;
    6975           0 :   int alloc2 = 0 ;
    6976           0 :   PyObject * obj0 = 0 ;
    6977           0 :   PyObject * obj1 = 0 ;
    6978             :   
    6979           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:CompositingFilter_filter_set",&obj0,&obj1)) SWIG_fail;
    6980           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 |  0 );
    6981           0 :   if (!SWIG_IsOK(res1)) {
    6982           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_filter_set" "', argument " "1"" of type '" "struct _CompositingFilter *""'"); 
    6983             :   }
    6984           0 :   arg1 = (struct _CompositingFilter *)(argp1);
    6985           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    6986           0 :   if (!SWIG_IsOK(res2)) {
    6987           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositingFilter_filter_set" "', argument " "2"" of type '" "char *""'");
    6988             :   }
    6989           0 :   arg2 = (char *)(buf2);
    6990             :   {
    6991           0 :     if (arg1->filter) free((char*)arg1->filter);
    6992           0 :     if (arg2) {
    6993           0 :       arg1->filter = (char *) malloc(strlen(arg2)+1);
    6994             :       strcpy((char*)arg1->filter,arg2);
    6995             :     } else {
    6996           0 :       arg1->filter = 0;
    6997             :     }
    6998             :   }
    6999             :   resultobj = SWIG_Py_Void();
    7000           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7001             :   return resultobj;
    7002           0 : fail:
    7003           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7004             :   return NULL;
    7005             : }
    7006             : 
    7007             : 
    7008           0 : SWIGINTERN PyObject *_wrap_CompositingFilter_filter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7009             :   PyObject *resultobj = 0;
    7010             :   struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
    7011           0 :   void *argp1 = 0 ;
    7012             :   int res1 = 0 ;
    7013           0 :   PyObject * obj0 = 0 ;
    7014             :   char *result = 0 ;
    7015             :   
    7016           0 :   if (!PyArg_ParseTuple(args,(char *)"O:CompositingFilter_filter_get",&obj0)) SWIG_fail;
    7017           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 |  0 );
    7018           0 :   if (!SWIG_IsOK(res1)) {
    7019           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_filter_get" "', argument " "1"" of type '" "struct _CompositingFilter *""'"); 
    7020             :   }
    7021           0 :   arg1 = (struct _CompositingFilter *)(argp1);
    7022           0 :   result = (char *) ((arg1)->filter);
    7023           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    7024           0 :   return resultobj;
    7025           0 : fail:
    7026             :   return NULL;
    7027             : }
    7028             : 
    7029             : 
    7030           0 : SWIGINTERN PyObject *_wrap_CompositingFilter_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7031             :   PyObject *resultobj = 0;
    7032             :   struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
    7033             :   struct _CompositingFilter *arg2 = (struct _CompositingFilter *) 0 ;
    7034           0 :   void *argp1 = 0 ;
    7035             :   int res1 = 0 ;
    7036           0 :   void *argp2 = 0 ;
    7037             :   int res2 = 0 ;
    7038           0 :   PyObject * obj0 = 0 ;
    7039           0 :   PyObject * obj1 = 0 ;
    7040             :   
    7041           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:CompositingFilter_next_set",&obj0,&obj1)) SWIG_fail;
    7042           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 |  0 );
    7043           0 :   if (!SWIG_IsOK(res1)) {
    7044           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_next_set" "', argument " "1"" of type '" "struct _CompositingFilter *""'"); 
    7045             :   }
    7046           0 :   arg1 = (struct _CompositingFilter *)(argp1);
    7047           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CompositingFilter, SWIG_POINTER_DISOWN |  0 );
    7048           0 :   if (!SWIG_IsOK(res2)) {
    7049           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositingFilter_next_set" "', argument " "2"" of type '" "struct _CompositingFilter *""'"); 
    7050             :   }
    7051           0 :   arg2 = (struct _CompositingFilter *)(argp2);
    7052           0 :   if (arg1) (arg1)->next = arg2;
    7053             :   resultobj = SWIG_Py_Void();
    7054           0 :   return resultobj;
    7055           0 : fail:
    7056             :   return NULL;
    7057             : }
    7058             : 
    7059             : 
    7060           0 : SWIGINTERN PyObject *_wrap_CompositingFilter_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7061             :   PyObject *resultobj = 0;
    7062             :   struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
    7063           0 :   void *argp1 = 0 ;
    7064             :   int res1 = 0 ;
    7065           0 :   PyObject * obj0 = 0 ;
    7066             :   struct _CompositingFilter *result = 0 ;
    7067             :   
    7068           0 :   if (!PyArg_ParseTuple(args,(char *)"O:CompositingFilter_next_get",&obj0)) SWIG_fail;
    7069           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 |  0 );
    7070           0 :   if (!SWIG_IsOK(res1)) {
    7071           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_next_get" "', argument " "1"" of type '" "struct _CompositingFilter *""'"); 
    7072             :   }
    7073           0 :   arg1 = (struct _CompositingFilter *)(argp1);
    7074           0 :   result = (struct _CompositingFilter *) ((arg1)->next);
    7075           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CompositingFilter, 0 |  0 );
    7076           0 :   return resultobj;
    7077           0 : fail:
    7078             :   return NULL;
    7079             : }
    7080             : 
    7081             : 
    7082           0 : SWIGINTERN PyObject *_wrap_new_CompositingFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7083             :   PyObject *resultobj = 0;
    7084             :   struct _CompositingFilter *result = 0 ;
    7085             :   
    7086           0 :   if (!PyArg_ParseTuple(args,(char *)":new_CompositingFilter")) SWIG_fail;
    7087             :   {
    7088           0 :     result = (struct _CompositingFilter *)calloc(1, sizeof(struct _CompositingFilter)); {
    7089           0 :       errorObj *ms_error = msGetErrorObj();
    7090             :       
    7091           0 :       switch(ms_error->code) {
    7092             :       case MS_NOERR:
    7093             :         break;
    7094           0 :       case MS_NOTFOUND:
    7095           0 :         msResetErrorList();
    7096           0 :         break;
    7097             :       case -1:
    7098             :         break;
    7099           0 :       case MS_IOERR:
    7100           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7101           0 :           _raise_ms_exception();
    7102           0 :           msResetErrorList();
    7103           0 :           return NULL;
    7104             :         }
    7105             :       default:
    7106           0 :         _raise_ms_exception();
    7107           0 :         msResetErrorList();
    7108           0 :         return NULL;
    7109             :       }
    7110             :       
    7111             :     }
    7112             :   }
    7113           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CompositingFilter, SWIG_POINTER_NEW |  0 );
    7114           0 :   return resultobj;
    7115           0 : fail:
    7116             :   return NULL;
    7117             : }
    7118             : 
    7119             : 
    7120           0 : SWIGINTERN PyObject *_wrap_delete_CompositingFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7121             :   PyObject *resultobj = 0;
    7122             :   struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
    7123           0 :   void *argp1 = 0 ;
    7124             :   int res1 = 0 ;
    7125           0 :   PyObject * obj0 = 0 ;
    7126             :   
    7127           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_CompositingFilter",&obj0)) SWIG_fail;
    7128           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, SWIG_POINTER_DISOWN |  0 );
    7129           0 :   if (!SWIG_IsOK(res1)) {
    7130           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositingFilter" "', argument " "1"" of type '" "struct _CompositingFilter *""'"); 
    7131             :   }
    7132           0 :   arg1 = (struct _CompositingFilter *)(argp1);
    7133             :   {
    7134           0 :     free((char *) arg1); {
    7135           0 :       errorObj *ms_error = msGetErrorObj();
    7136             :       
    7137           0 :       switch(ms_error->code) {
    7138             :       case MS_NOERR:
    7139             :         break;
    7140           0 :       case MS_NOTFOUND:
    7141           0 :         msResetErrorList();
    7142           0 :         break;
    7143             :       case -1:
    7144             :         break;
    7145           0 :       case MS_IOERR:
    7146           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7147           0 :           _raise_ms_exception();
    7148           0 :           msResetErrorList();
    7149           0 :           return NULL;
    7150             :         }
    7151             :       default:
    7152           0 :         _raise_ms_exception();
    7153           0 :         msResetErrorList();
    7154           0 :         return NULL;
    7155             :       }
    7156             :       
    7157             :     }
    7158             :   }
    7159             :   resultobj = SWIG_Py_Void();
    7160           0 :   return resultobj;
    7161           0 : fail:
    7162             :   return NULL;
    7163             : }
    7164             : 
    7165             : 
    7166           1 : SWIGINTERN PyObject *CompositingFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7167             :   PyObject *obj;
    7168           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    7169           1 :   SWIG_TypeNewClientData(SWIGTYPE_p__CompositingFilter, SWIG_NewClientData(obj));
    7170           1 :   return SWIG_Py_Void();
    7171             : }
    7172             : 
    7173           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_comp_op_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7174             :   PyObject *resultobj = 0;
    7175             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7176             :   CompositingOperation arg2 ;
    7177           0 :   void *argp1 = 0 ;
    7178             :   int res1 = 0 ;
    7179             :   int val2 ;
    7180             :   int ecode2 = 0 ;
    7181           0 :   PyObject * obj0 = 0 ;
    7182           0 :   PyObject * obj1 = 0 ;
    7183             :   
    7184           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_comp_op_set",&obj0,&obj1)) SWIG_fail;
    7185           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7186           0 :   if (!SWIG_IsOK(res1)) {
    7187           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_comp_op_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7188             :   }
    7189           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7190           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    7191           0 :   if (!SWIG_IsOK(ecode2)) {
    7192           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerCompositer_comp_op_set" "', argument " "2"" of type '" "CompositingOperation""'");
    7193             :   } 
    7194           0 :   arg2 = (CompositingOperation)(val2);
    7195           0 :   if (arg1) (arg1)->comp_op = arg2;
    7196             :   resultobj = SWIG_Py_Void();
    7197           0 :   return resultobj;
    7198           0 : fail:
    7199             :   return NULL;
    7200             : }
    7201             : 
    7202             : 
    7203           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_comp_op_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7204             :   PyObject *resultobj = 0;
    7205             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7206           0 :   void *argp1 = 0 ;
    7207             :   int res1 = 0 ;
    7208           0 :   PyObject * obj0 = 0 ;
    7209             :   CompositingOperation result;
    7210             :   
    7211           0 :   if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_comp_op_get",&obj0)) SWIG_fail;
    7212           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7213           0 :   if (!SWIG_IsOK(res1)) {
    7214           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_comp_op_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7215             :   }
    7216           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7217           0 :   result = (CompositingOperation) ((arg1)->comp_op);
    7218           0 :   resultobj = SWIG_From_int((int)(result));
    7219           0 :   return resultobj;
    7220           0 : fail:
    7221             :   return NULL;
    7222             : }
    7223             : 
    7224             : 
    7225           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_opacity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7226             :   PyObject *resultobj = 0;
    7227             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7228             :   int arg2 ;
    7229           0 :   void *argp1 = 0 ;
    7230             :   int res1 = 0 ;
    7231             :   int val2 ;
    7232             :   int ecode2 = 0 ;
    7233           0 :   PyObject * obj0 = 0 ;
    7234           0 :   PyObject * obj1 = 0 ;
    7235             :   
    7236           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_opacity_set",&obj0,&obj1)) SWIG_fail;
    7237           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7238           0 :   if (!SWIG_IsOK(res1)) {
    7239           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_opacity_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7240             :   }
    7241           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7242           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    7243           0 :   if (!SWIG_IsOK(ecode2)) {
    7244           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerCompositer_opacity_set" "', argument " "2"" of type '" "int""'");
    7245             :   } 
    7246             :   arg2 = (int)(val2);
    7247           0 :   if (arg1) (arg1)->opacity = arg2;
    7248             :   resultobj = SWIG_Py_Void();
    7249           0 :   return resultobj;
    7250           0 : fail:
    7251             :   return NULL;
    7252             : }
    7253             : 
    7254             : 
    7255           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_opacity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7256             :   PyObject *resultobj = 0;
    7257             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7258           0 :   void *argp1 = 0 ;
    7259             :   int res1 = 0 ;
    7260           0 :   PyObject * obj0 = 0 ;
    7261             :   int result;
    7262             :   
    7263           0 :   if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_opacity_get",&obj0)) SWIG_fail;
    7264           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7265           0 :   if (!SWIG_IsOK(res1)) {
    7266           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_opacity_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7267             :   }
    7268           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7269           0 :   result = (int) ((arg1)->opacity);
    7270             :   resultobj = SWIG_From_int((int)(result));
    7271           0 :   return resultobj;
    7272           0 : fail:
    7273             :   return NULL;
    7274             : }
    7275             : 
    7276             : 
    7277           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_filter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7278             :   PyObject *resultobj = 0;
    7279             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7280             :   CompositingFilter *arg2 = (CompositingFilter *) 0 ;
    7281           0 :   void *argp1 = 0 ;
    7282             :   int res1 = 0 ;
    7283           0 :   void *argp2 = 0 ;
    7284             :   int res2 = 0 ;
    7285           0 :   PyObject * obj0 = 0 ;
    7286           0 :   PyObject * obj1 = 0 ;
    7287             :   
    7288           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_filter_set",&obj0,&obj1)) SWIG_fail;
    7289           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7290           0 :   if (!SWIG_IsOK(res1)) {
    7291           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_filter_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7292             :   }
    7293           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7294           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CompositingFilter, SWIG_POINTER_DISOWN |  0 );
    7295           0 :   if (!SWIG_IsOK(res2)) {
    7296           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayerCompositer_filter_set" "', argument " "2"" of type '" "CompositingFilter *""'"); 
    7297             :   }
    7298           0 :   arg2 = (CompositingFilter *)(argp2);
    7299           0 :   if (arg1) (arg1)->filter = arg2;
    7300             :   resultobj = SWIG_Py_Void();
    7301           0 :   return resultobj;
    7302           0 : fail:
    7303             :   return NULL;
    7304             : }
    7305             : 
    7306             : 
    7307           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_filter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7308             :   PyObject *resultobj = 0;
    7309             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7310           0 :   void *argp1 = 0 ;
    7311             :   int res1 = 0 ;
    7312           0 :   PyObject * obj0 = 0 ;
    7313             :   CompositingFilter *result = 0 ;
    7314             :   
    7315           0 :   if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_filter_get",&obj0)) SWIG_fail;
    7316           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7317           0 :   if (!SWIG_IsOK(res1)) {
    7318           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_filter_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7319             :   }
    7320           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7321           0 :   result = (CompositingFilter *) ((arg1)->filter);
    7322           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CompositingFilter, 0 |  0 );
    7323           0 :   return resultobj;
    7324           0 : fail:
    7325             :   return NULL;
    7326             : }
    7327             : 
    7328             : 
    7329           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7330             :   PyObject *resultobj = 0;
    7331             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7332             :   struct _LayerCompositer *arg2 = (struct _LayerCompositer *) 0 ;
    7333           0 :   void *argp1 = 0 ;
    7334             :   int res1 = 0 ;
    7335           0 :   void *argp2 = 0 ;
    7336             :   int res2 = 0 ;
    7337           0 :   PyObject * obj0 = 0 ;
    7338           0 :   PyObject * obj1 = 0 ;
    7339             :   
    7340           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_next_set",&obj0,&obj1)) SWIG_fail;
    7341           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7342           0 :   if (!SWIG_IsOK(res1)) {
    7343           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_next_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7344             :   }
    7345           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7346           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__LayerCompositer, SWIG_POINTER_DISOWN |  0 );
    7347           0 :   if (!SWIG_IsOK(res2)) {
    7348           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayerCompositer_next_set" "', argument " "2"" of type '" "struct _LayerCompositer *""'"); 
    7349             :   }
    7350           0 :   arg2 = (struct _LayerCompositer *)(argp2);
    7351           0 :   if (arg1) (arg1)->next = arg2;
    7352             :   resultobj = SWIG_Py_Void();
    7353           0 :   return resultobj;
    7354           0 : fail:
    7355             :   return NULL;
    7356             : }
    7357             : 
    7358             : 
    7359           0 : SWIGINTERN PyObject *_wrap_LayerCompositer_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7360             :   PyObject *resultobj = 0;
    7361             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7362           0 :   void *argp1 = 0 ;
    7363             :   int res1 = 0 ;
    7364           0 :   PyObject * obj0 = 0 ;
    7365             :   struct _LayerCompositer *result = 0 ;
    7366             :   
    7367           0 :   if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_next_get",&obj0)) SWIG_fail;
    7368           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7369           0 :   if (!SWIG_IsOK(res1)) {
    7370           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_next_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7371             :   }
    7372           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7373           0 :   result = (struct _LayerCompositer *) ((arg1)->next);
    7374           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__LayerCompositer, 0 |  0 );
    7375           0 :   return resultobj;
    7376           0 : fail:
    7377             :   return NULL;
    7378             : }
    7379             : 
    7380             : 
    7381           0 : SWIGINTERN PyObject *_wrap_new_LayerCompositer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7382             :   PyObject *resultobj = 0;
    7383             :   struct _LayerCompositer *result = 0 ;
    7384             :   
    7385           0 :   if (!PyArg_ParseTuple(args,(char *)":new_LayerCompositer")) SWIG_fail;
    7386             :   {
    7387           0 :     result = (struct _LayerCompositer *)calloc(1, sizeof(struct _LayerCompositer)); {
    7388           0 :       errorObj *ms_error = msGetErrorObj();
    7389             :       
    7390           0 :       switch(ms_error->code) {
    7391             :       case MS_NOERR:
    7392             :         break;
    7393           0 :       case MS_NOTFOUND:
    7394           0 :         msResetErrorList();
    7395           0 :         break;
    7396             :       case -1:
    7397             :         break;
    7398           0 :       case MS_IOERR:
    7399           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7400           0 :           _raise_ms_exception();
    7401           0 :           msResetErrorList();
    7402           0 :           return NULL;
    7403             :         }
    7404             :       default:
    7405           0 :         _raise_ms_exception();
    7406           0 :         msResetErrorList();
    7407           0 :         return NULL;
    7408             :       }
    7409             :       
    7410             :     }
    7411             :   }
    7412           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__LayerCompositer, SWIG_POINTER_NEW |  0 );
    7413           0 :   return resultobj;
    7414           0 : fail:
    7415             :   return NULL;
    7416             : }
    7417             : 
    7418             : 
    7419           0 : SWIGINTERN PyObject *_wrap_delete_LayerCompositer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7420             :   PyObject *resultobj = 0;
    7421             :   struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
    7422           0 :   void *argp1 = 0 ;
    7423             :   int res1 = 0 ;
    7424           0 :   PyObject * obj0 = 0 ;
    7425             :   
    7426           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_LayerCompositer",&obj0)) SWIG_fail;
    7427           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, SWIG_POINTER_DISOWN |  0 );
    7428           0 :   if (!SWIG_IsOK(res1)) {
    7429           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayerCompositer" "', argument " "1"" of type '" "struct _LayerCompositer *""'"); 
    7430             :   }
    7431           0 :   arg1 = (struct _LayerCompositer *)(argp1);
    7432             :   {
    7433           0 :     free((char *) arg1); {
    7434           0 :       errorObj *ms_error = msGetErrorObj();
    7435             :       
    7436           0 :       switch(ms_error->code) {
    7437             :       case MS_NOERR:
    7438             :         break;
    7439           0 :       case MS_NOTFOUND:
    7440           0 :         msResetErrorList();
    7441           0 :         break;
    7442             :       case -1:
    7443             :         break;
    7444           0 :       case MS_IOERR:
    7445           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7446           0 :           _raise_ms_exception();
    7447           0 :           msResetErrorList();
    7448           0 :           return NULL;
    7449             :         }
    7450             :       default:
    7451           0 :         _raise_ms_exception();
    7452           0 :         msResetErrorList();
    7453           0 :         return NULL;
    7454             :       }
    7455             :       
    7456             :     }
    7457             :   }
    7458             :   resultobj = SWIG_Py_Void();
    7459           0 :   return resultobj;
    7460           0 : fail:
    7461             :   return NULL;
    7462             : }
    7463             : 
    7464             : 
    7465           1 : SWIGINTERN PyObject *LayerCompositer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7466             :   PyObject *obj;
    7467           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    7468           1 :   SWIG_TypeNewClientData(SWIGTYPE_p__LayerCompositer, SWIG_NewClientData(obj));
    7469           1 :   return SWIG_Py_Void();
    7470             : }
    7471             : 
    7472           1 : SWIGINTERN PyObject *_wrap_fontSetObj_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7473             :   PyObject *resultobj = 0;
    7474             :   fontSetObj *arg1 = (fontSetObj *) 0 ;
    7475           1 :   void *argp1 = 0 ;
    7476             :   int res1 = 0 ;
    7477           1 :   PyObject * obj0 = 0 ;
    7478             :   char *result = 0 ;
    7479             :   
    7480           1 :   if (!PyArg_ParseTuple(args,(char *)"O:fontSetObj_filename_get",&obj0)) SWIG_fail;
    7481           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, 0 |  0 );
    7482           1 :   if (!SWIG_IsOK(res1)) {
    7483           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fontSetObj_filename_get" "', argument " "1"" of type '" "fontSetObj *""'"); 
    7484             :   }
    7485           1 :   arg1 = (fontSetObj *)(argp1);
    7486           1 :   result = (char *) ((arg1)->filename);
    7487           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    7488           1 :   return resultobj;
    7489           0 : fail:
    7490             :   return NULL;
    7491             : }
    7492             : 
    7493             : 
    7494           1 : SWIGINTERN PyObject *_wrap_fontSetObj_numfonts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7495             :   PyObject *resultobj = 0;
    7496             :   fontSetObj *arg1 = (fontSetObj *) 0 ;
    7497           1 :   void *argp1 = 0 ;
    7498             :   int res1 = 0 ;
    7499           1 :   PyObject * obj0 = 0 ;
    7500             :   int result;
    7501             :   
    7502           1 :   if (!PyArg_ParseTuple(args,(char *)"O:fontSetObj_numfonts_get",&obj0)) SWIG_fail;
    7503           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, 0 |  0 );
    7504           1 :   if (!SWIG_IsOK(res1)) {
    7505           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fontSetObj_numfonts_get" "', argument " "1"" of type '" "fontSetObj *""'"); 
    7506             :   }
    7507           1 :   arg1 = (fontSetObj *)(argp1);
    7508           1 :   result = (int) ((arg1)->numfonts);
    7509             :   resultobj = SWIG_From_int((int)(result));
    7510           1 :   return resultobj;
    7511           0 : fail:
    7512             :   return NULL;
    7513             : }
    7514             : 
    7515             : 
    7516           1 : SWIGINTERN PyObject *_wrap_fontSetObj_fonts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7517             :   PyObject *resultobj = 0;
    7518             :   fontSetObj *arg1 = (fontSetObj *) 0 ;
    7519           1 :   void *argp1 = 0 ;
    7520             :   int res1 = 0 ;
    7521           1 :   PyObject * obj0 = 0 ;
    7522             :   hashTableObj *result = 0 ;
    7523             :   
    7524           1 :   if (!PyArg_ParseTuple(args,(char *)"O:fontSetObj_fonts_get",&obj0)) SWIG_fail;
    7525           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, 0 |  0 );
    7526           1 :   if (!SWIG_IsOK(res1)) {
    7527           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fontSetObj_fonts_get" "', argument " "1"" of type '" "fontSetObj *""'"); 
    7528             :   }
    7529           1 :   arg1 = (fontSetObj *)(argp1);
    7530           1 :   result = (hashTableObj *)& ((arg1)->fonts);
    7531           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
    7532           1 :   return resultobj;
    7533           0 : fail:
    7534             :   return NULL;
    7535             : }
    7536             : 
    7537             : 
    7538           0 : SWIGINTERN PyObject *_wrap_new_fontSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7539             :   PyObject *resultobj = 0;
    7540             :   fontSetObj *result = 0 ;
    7541             :   
    7542           0 :   if (!PyArg_ParseTuple(args,(char *)":new_fontSetObj")) SWIG_fail;
    7543             :   {
    7544           0 :     result = (fontSetObj *)calloc(1, sizeof(fontSetObj)); {
    7545           0 :       errorObj *ms_error = msGetErrorObj();
    7546             :       
    7547           0 :       switch(ms_error->code) {
    7548             :       case MS_NOERR:
    7549             :         break;
    7550           0 :       case MS_NOTFOUND:
    7551           0 :         msResetErrorList();
    7552           0 :         break;
    7553             :       case -1:
    7554             :         break;
    7555           0 :       case MS_IOERR:
    7556           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7557           0 :           _raise_ms_exception();
    7558           0 :           msResetErrorList();
    7559           0 :           return NULL;
    7560             :         }
    7561             :       default:
    7562           0 :         _raise_ms_exception();
    7563           0 :         msResetErrorList();
    7564           0 :         return NULL;
    7565             :       }
    7566             :       
    7567             :     }
    7568             :   }
    7569           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fontSetObj, SWIG_POINTER_NEW |  0 );
    7570           0 :   return resultobj;
    7571           0 : fail:
    7572             :   return NULL;
    7573             : }
    7574             : 
    7575             : 
    7576           0 : SWIGINTERN PyObject *_wrap_delete_fontSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7577             :   PyObject *resultobj = 0;
    7578             :   fontSetObj *arg1 = (fontSetObj *) 0 ;
    7579           0 :   void *argp1 = 0 ;
    7580             :   int res1 = 0 ;
    7581           0 :   PyObject * obj0 = 0 ;
    7582             :   
    7583           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_fontSetObj",&obj0)) SWIG_fail;
    7584           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, SWIG_POINTER_DISOWN |  0 );
    7585           0 :   if (!SWIG_IsOK(res1)) {
    7586           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fontSetObj" "', argument " "1"" of type '" "fontSetObj *""'"); 
    7587             :   }
    7588           0 :   arg1 = (fontSetObj *)(argp1);
    7589             :   {
    7590           0 :     free((char *) arg1); {
    7591           0 :       errorObj *ms_error = msGetErrorObj();
    7592             :       
    7593           0 :       switch(ms_error->code) {
    7594             :       case MS_NOERR:
    7595             :         break;
    7596           0 :       case MS_NOTFOUND:
    7597           0 :         msResetErrorList();
    7598           0 :         break;
    7599             :       case -1:
    7600             :         break;
    7601           0 :       case MS_IOERR:
    7602           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7603           0 :           _raise_ms_exception();
    7604           0 :           msResetErrorList();
    7605           0 :           return NULL;
    7606             :         }
    7607             :       default:
    7608           0 :         _raise_ms_exception();
    7609           0 :         msResetErrorList();
    7610           0 :         return NULL;
    7611             :       }
    7612             :       
    7613             :     }
    7614             :   }
    7615             :   resultobj = SWIG_Py_Void();
    7616           0 :   return resultobj;
    7617           0 : fail:
    7618             :   return NULL;
    7619             : }
    7620             : 
    7621             : 
    7622           1 : SWIGINTERN PyObject *fontSetObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7623             :   PyObject *obj;
    7624           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    7625           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_fontSetObj, SWIG_NewClientData(obj));
    7626           1 :   return SWIG_Py_Void();
    7627             : }
    7628             : 
    7629           0 : SWIGINTERN PyObject *_wrap_clusterObj_maxdistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7630             :   PyObject *resultobj = 0;
    7631             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7632             :   double arg2 ;
    7633           0 :   void *argp1 = 0 ;
    7634             :   int res1 = 0 ;
    7635             :   double val2 ;
    7636             :   int ecode2 = 0 ;
    7637           0 :   PyObject * obj0 = 0 ;
    7638           0 :   PyObject * obj1 = 0 ;
    7639             :   
    7640           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_maxdistance_set",&obj0,&obj1)) SWIG_fail;
    7641           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7642           0 :   if (!SWIG_IsOK(res1)) {
    7643           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_maxdistance_set" "', argument " "1"" of type '" "clusterObj *""'"); 
    7644             :   }
    7645           0 :   arg1 = (clusterObj *)(argp1);
    7646           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
    7647           0 :   if (!SWIG_IsOK(ecode2)) {
    7648           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clusterObj_maxdistance_set" "', argument " "2"" of type '" "double""'");
    7649             :   } 
    7650           0 :   arg2 = (double)(val2);
    7651           0 :   if (arg1) (arg1)->maxdistance = arg2;
    7652             :   resultobj = SWIG_Py_Void();
    7653           0 :   return resultobj;
    7654           0 : fail:
    7655             :   return NULL;
    7656             : }
    7657             : 
    7658             : 
    7659           1 : SWIGINTERN PyObject *_wrap_clusterObj_maxdistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7660             :   PyObject *resultobj = 0;
    7661             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7662           1 :   void *argp1 = 0 ;
    7663             :   int res1 = 0 ;
    7664           1 :   PyObject * obj0 = 0 ;
    7665             :   double result;
    7666             :   
    7667           1 :   if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_maxdistance_get",&obj0)) SWIG_fail;
    7668           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7669           1 :   if (!SWIG_IsOK(res1)) {
    7670           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_maxdistance_get" "', argument " "1"" of type '" "clusterObj *""'"); 
    7671             :   }
    7672           1 :   arg1 = (clusterObj *)(argp1);
    7673           1 :   result = (double) ((arg1)->maxdistance);
    7674           1 :   resultobj = SWIG_From_double((double)(result));
    7675           1 :   return resultobj;
    7676           0 : fail:
    7677             :   return NULL;
    7678             : }
    7679             : 
    7680             : 
    7681           0 : SWIGINTERN PyObject *_wrap_clusterObj_buffer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7682             :   PyObject *resultobj = 0;
    7683             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7684             :   double arg2 ;
    7685           0 :   void *argp1 = 0 ;
    7686             :   int res1 = 0 ;
    7687             :   double val2 ;
    7688             :   int ecode2 = 0 ;
    7689           0 :   PyObject * obj0 = 0 ;
    7690           0 :   PyObject * obj1 = 0 ;
    7691             :   
    7692           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_buffer_set",&obj0,&obj1)) SWIG_fail;
    7693           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7694           0 :   if (!SWIG_IsOK(res1)) {
    7695           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_buffer_set" "', argument " "1"" of type '" "clusterObj *""'"); 
    7696             :   }
    7697           0 :   arg1 = (clusterObj *)(argp1);
    7698           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
    7699           0 :   if (!SWIG_IsOK(ecode2)) {
    7700           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clusterObj_buffer_set" "', argument " "2"" of type '" "double""'");
    7701             :   } 
    7702           0 :   arg2 = (double)(val2);
    7703           0 :   if (arg1) (arg1)->buffer = arg2;
    7704             :   resultobj = SWIG_Py_Void();
    7705           0 :   return resultobj;
    7706           0 : fail:
    7707             :   return NULL;
    7708             : }
    7709             : 
    7710             : 
    7711           0 : SWIGINTERN PyObject *_wrap_clusterObj_buffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7712             :   PyObject *resultobj = 0;
    7713             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7714           0 :   void *argp1 = 0 ;
    7715             :   int res1 = 0 ;
    7716           0 :   PyObject * obj0 = 0 ;
    7717             :   double result;
    7718             :   
    7719           0 :   if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_buffer_get",&obj0)) SWIG_fail;
    7720           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7721           0 :   if (!SWIG_IsOK(res1)) {
    7722           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_buffer_get" "', argument " "1"" of type '" "clusterObj *""'"); 
    7723             :   }
    7724           0 :   arg1 = (clusterObj *)(argp1);
    7725           0 :   result = (double) ((arg1)->buffer);
    7726           0 :   resultobj = SWIG_From_double((double)(result));
    7727           0 :   return resultobj;
    7728           0 : fail:
    7729             :   return NULL;
    7730             : }
    7731             : 
    7732             : 
    7733           0 : SWIGINTERN PyObject *_wrap_clusterObj_region_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7734             :   PyObject *resultobj = 0;
    7735             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7736             :   char *arg2 = (char *) 0 ;
    7737           0 :   void *argp1 = 0 ;
    7738             :   int res1 = 0 ;
    7739             :   int res2 ;
    7740           0 :   char *buf2 = 0 ;
    7741           0 :   int alloc2 = 0 ;
    7742           0 :   PyObject * obj0 = 0 ;
    7743           0 :   PyObject * obj1 = 0 ;
    7744             :   
    7745           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_region_set",&obj0,&obj1)) SWIG_fail;
    7746           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7747           0 :   if (!SWIG_IsOK(res1)) {
    7748           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_region_set" "', argument " "1"" of type '" "clusterObj *""'"); 
    7749             :   }
    7750           0 :   arg1 = (clusterObj *)(argp1);
    7751           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    7752           0 :   if (!SWIG_IsOK(res2)) {
    7753           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_region_set" "', argument " "2"" of type '" "char *""'");
    7754             :   }
    7755           0 :   arg2 = (char *)(buf2);
    7756             :   {
    7757           0 :     if (arg1->region) free((char*)arg1->region);
    7758           0 :     if (arg2) {
    7759           0 :       arg1->region = (char *) malloc(strlen(arg2)+1);
    7760             :       strcpy((char*)arg1->region,arg2);
    7761             :     } else {
    7762           0 :       arg1->region = 0;
    7763             :     }
    7764             :   }
    7765             :   resultobj = SWIG_Py_Void();
    7766           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7767             :   return resultobj;
    7768           0 : fail:
    7769           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7770             :   return NULL;
    7771             : }
    7772             : 
    7773             : 
    7774           1 : SWIGINTERN PyObject *_wrap_clusterObj_region_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7775             :   PyObject *resultobj = 0;
    7776             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7777           1 :   void *argp1 = 0 ;
    7778             :   int res1 = 0 ;
    7779           1 :   PyObject * obj0 = 0 ;
    7780             :   char *result = 0 ;
    7781             :   
    7782           1 :   if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_region_get",&obj0)) SWIG_fail;
    7783           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7784           1 :   if (!SWIG_IsOK(res1)) {
    7785           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_region_get" "', argument " "1"" of type '" "clusterObj *""'"); 
    7786             :   }
    7787           1 :   arg1 = (clusterObj *)(argp1);
    7788           1 :   result = (char *) ((arg1)->region);
    7789           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    7790           1 :   return resultobj;
    7791           0 : fail:
    7792             :   return NULL;
    7793             : }
    7794             : 
    7795             : 
    7796           1 : SWIGINTERN PyObject *_wrap_clusterObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7797             :   PyObject *resultobj = 0;
    7798             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7799             :   char *arg2 = (char *) 0 ;
    7800           1 :   void *argp1 = 0 ;
    7801             :   int res1 = 0 ;
    7802             :   int res2 ;
    7803           1 :   char *buf2 = 0 ;
    7804           1 :   int alloc2 = 0 ;
    7805           1 :   PyObject * obj0 = 0 ;
    7806           1 :   PyObject * obj1 = 0 ;
    7807             :   int result;
    7808             :   
    7809           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_updateFromString",&obj0,&obj1)) SWIG_fail;
    7810           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7811           1 :   if (!SWIG_IsOK(res1)) {
    7812           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_updateFromString" "', argument " "1"" of type '" "clusterObj *""'"); 
    7813             :   }
    7814           1 :   arg1 = (clusterObj *)(argp1);
    7815           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    7816           1 :   if (!SWIG_IsOK(res2)) {
    7817           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_updateFromString" "', argument " "2"" of type '" "char *""'");
    7818             :   }
    7819           1 :   arg2 = (char *)(buf2);
    7820             :   {
    7821             :     result = (int)clusterObj_updateFromString(arg1,arg2); {
    7822           1 :       errorObj *ms_error = msGetErrorObj();
    7823             :       
    7824           1 :       switch(ms_error->code) {
    7825             :       case MS_NOERR:
    7826             :         break;
    7827           0 :       case MS_NOTFOUND:
    7828           0 :         msResetErrorList();
    7829           0 :         break;
    7830             :       case -1:
    7831             :         break;
    7832           0 :       case MS_IOERR:
    7833           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7834           0 :           _raise_ms_exception();
    7835           0 :           msResetErrorList();
    7836           0 :           return NULL;
    7837             :         }
    7838             :       default:
    7839           0 :         _raise_ms_exception();
    7840           0 :         msResetErrorList();
    7841           0 :         return NULL;
    7842             :       }
    7843             :       
    7844             :     }
    7845             :   }
    7846             :   resultobj = SWIG_From_int((int)(result));
    7847           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7848             :   return resultobj;
    7849           0 : fail:
    7850           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7851             :   return NULL;
    7852             : }
    7853             : 
    7854             : 
    7855           1 : SWIGINTERN PyObject *_wrap_clusterObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7856             :   PyObject *resultobj = 0;
    7857             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7858           1 :   void *argp1 = 0 ;
    7859             :   int res1 = 0 ;
    7860           1 :   PyObject * obj0 = 0 ;
    7861             :   char *result = 0 ;
    7862             :   
    7863           1 :   if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_convertToString",&obj0)) SWIG_fail;
    7864           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7865           1 :   if (!SWIG_IsOK(res1)) {
    7866           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_convertToString" "', argument " "1"" of type '" "clusterObj *""'"); 
    7867             :   }
    7868           1 :   arg1 = (clusterObj *)(argp1);
    7869             :   {
    7870             :     result = (char *)clusterObj_convertToString(arg1); {
    7871           1 :       errorObj *ms_error = msGetErrorObj();
    7872             :       
    7873           1 :       switch(ms_error->code) {
    7874             :       case MS_NOERR:
    7875             :         break;
    7876           0 :       case MS_NOTFOUND:
    7877           0 :         msResetErrorList();
    7878           0 :         break;
    7879             :       case -1:
    7880             :         break;
    7881           0 :       case MS_IOERR:
    7882           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7883           0 :           _raise_ms_exception();
    7884           0 :           msResetErrorList();
    7885           0 :           return NULL;
    7886             :         }
    7887             :       default:
    7888           0 :         _raise_ms_exception();
    7889           0 :         msResetErrorList();
    7890           0 :         return NULL;
    7891             :       }
    7892             :       
    7893             :     }
    7894             :   }
    7895           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    7896           1 :   free((char*)result);
    7897           1 :   return resultobj;
    7898           0 : fail:
    7899             :   return NULL;
    7900             : }
    7901             : 
    7902             : 
    7903           1 : SWIGINTERN PyObject *_wrap_clusterObj_setGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7904             :   PyObject *resultobj = 0;
    7905             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7906             :   char *arg2 = (char *) 0 ;
    7907           1 :   void *argp1 = 0 ;
    7908             :   int res1 = 0 ;
    7909             :   int res2 ;
    7910           1 :   char *buf2 = 0 ;
    7911           1 :   int alloc2 = 0 ;
    7912           1 :   PyObject * obj0 = 0 ;
    7913           1 :   PyObject * obj1 = 0 ;
    7914             :   int result;
    7915             :   
    7916           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_setGroup",&obj0,&obj1)) SWIG_fail;
    7917           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7918           1 :   if (!SWIG_IsOK(res1)) {
    7919           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_setGroup" "', argument " "1"" of type '" "clusterObj *""'"); 
    7920             :   }
    7921           1 :   arg1 = (clusterObj *)(argp1);
    7922           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    7923           1 :   if (!SWIG_IsOK(res2)) {
    7924           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_setGroup" "', argument " "2"" of type '" "char *""'");
    7925             :   }
    7926           1 :   arg2 = (char *)(buf2);
    7927             :   {
    7928           1 :     result = (int)clusterObj_setGroup(arg1,arg2); {
    7929           1 :       errorObj *ms_error = msGetErrorObj();
    7930             :       
    7931           1 :       switch(ms_error->code) {
    7932             :       case MS_NOERR:
    7933             :         break;
    7934           0 :       case MS_NOTFOUND:
    7935           0 :         msResetErrorList();
    7936           0 :         break;
    7937             :       case -1:
    7938             :         break;
    7939           0 :       case MS_IOERR:
    7940           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7941           0 :           _raise_ms_exception();
    7942           0 :           msResetErrorList();
    7943           0 :           return NULL;
    7944             :         }
    7945             :       default:
    7946           0 :         _raise_ms_exception();
    7947           0 :         msResetErrorList();
    7948           0 :         return NULL;
    7949             :       }
    7950             :       
    7951             :     }
    7952             :   }
    7953             :   resultobj = SWIG_From_int((int)(result));
    7954           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7955             :   return resultobj;
    7956           0 : fail:
    7957           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    7958             :   return NULL;
    7959             : }
    7960             : 
    7961             : 
    7962           1 : SWIGINTERN PyObject *_wrap_clusterObj_getGroupString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7963             :   PyObject *resultobj = 0;
    7964             :   clusterObj *arg1 = (clusterObj *) 0 ;
    7965           1 :   void *argp1 = 0 ;
    7966             :   int res1 = 0 ;
    7967           1 :   PyObject * obj0 = 0 ;
    7968             :   char *result = 0 ;
    7969             :   
    7970           1 :   if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_getGroupString",&obj0)) SWIG_fail;
    7971           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    7972           1 :   if (!SWIG_IsOK(res1)) {
    7973           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_getGroupString" "', argument " "1"" of type '" "clusterObj *""'"); 
    7974             :   }
    7975           1 :   arg1 = (clusterObj *)(argp1);
    7976             :   {
    7977             :     result = (char *)clusterObj_getGroupString(arg1); {
    7978           1 :       errorObj *ms_error = msGetErrorObj();
    7979             :       
    7980           1 :       switch(ms_error->code) {
    7981             :       case MS_NOERR:
    7982             :         break;
    7983           0 :       case MS_NOTFOUND:
    7984           0 :         msResetErrorList();
    7985           0 :         break;
    7986             :       case -1:
    7987             :         break;
    7988           0 :       case MS_IOERR:
    7989           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    7990           0 :           _raise_ms_exception();
    7991           0 :           msResetErrorList();
    7992           0 :           return NULL;
    7993             :         }
    7994             :       default:
    7995           0 :         _raise_ms_exception();
    7996           0 :         msResetErrorList();
    7997           0 :         return NULL;
    7998             :       }
    7999             :       
    8000             :     }
    8001             :   }
    8002           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8003           1 :   free((char*)result);
    8004           1 :   return resultobj;
    8005           0 : fail:
    8006             :   return NULL;
    8007             : }
    8008             : 
    8009             : 
    8010           1 : SWIGINTERN PyObject *_wrap_clusterObj_setFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8011             :   PyObject *resultobj = 0;
    8012             :   clusterObj *arg1 = (clusterObj *) 0 ;
    8013             :   char *arg2 = (char *) 0 ;
    8014           1 :   void *argp1 = 0 ;
    8015             :   int res1 = 0 ;
    8016             :   int res2 ;
    8017           1 :   char *buf2 = 0 ;
    8018           1 :   int alloc2 = 0 ;
    8019           1 :   PyObject * obj0 = 0 ;
    8020           1 :   PyObject * obj1 = 0 ;
    8021             :   int result;
    8022             :   
    8023           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_setFilter",&obj0,&obj1)) SWIG_fail;
    8024           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    8025           1 :   if (!SWIG_IsOK(res1)) {
    8026           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_setFilter" "', argument " "1"" of type '" "clusterObj *""'"); 
    8027             :   }
    8028           1 :   arg1 = (clusterObj *)(argp1);
    8029           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8030           1 :   if (!SWIG_IsOK(res2)) {
    8031           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_setFilter" "', argument " "2"" of type '" "char *""'");
    8032             :   }
    8033           1 :   arg2 = (char *)(buf2);
    8034             :   {
    8035           1 :     result = (int)clusterObj_setFilter(arg1,arg2); {
    8036           1 :       errorObj *ms_error = msGetErrorObj();
    8037             :       
    8038           1 :       switch(ms_error->code) {
    8039             :       case MS_NOERR:
    8040             :         break;
    8041           0 :       case MS_NOTFOUND:
    8042           0 :         msResetErrorList();
    8043           0 :         break;
    8044             :       case -1:
    8045             :         break;
    8046           0 :       case MS_IOERR:
    8047           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8048           0 :           _raise_ms_exception();
    8049           0 :           msResetErrorList();
    8050           0 :           return NULL;
    8051             :         }
    8052             :       default:
    8053           0 :         _raise_ms_exception();
    8054           0 :         msResetErrorList();
    8055           0 :         return NULL;
    8056             :       }
    8057             :       
    8058             :     }
    8059             :   }
    8060             :   resultobj = SWIG_From_int((int)(result));
    8061           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8062             :   return resultobj;
    8063           0 : fail:
    8064           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8065             :   return NULL;
    8066             : }
    8067             : 
    8068             : 
    8069           1 : SWIGINTERN PyObject *_wrap_clusterObj_getFilterString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8070             :   PyObject *resultobj = 0;
    8071             :   clusterObj *arg1 = (clusterObj *) 0 ;
    8072           1 :   void *argp1 = 0 ;
    8073             :   int res1 = 0 ;
    8074           1 :   PyObject * obj0 = 0 ;
    8075             :   char *result = 0 ;
    8076             :   
    8077           1 :   if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_getFilterString",&obj0)) SWIG_fail;
    8078           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 |  0 );
    8079           1 :   if (!SWIG_IsOK(res1)) {
    8080           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_getFilterString" "', argument " "1"" of type '" "clusterObj *""'"); 
    8081             :   }
    8082           1 :   arg1 = (clusterObj *)(argp1);
    8083             :   {
    8084             :     result = (char *)clusterObj_getFilterString(arg1); {
    8085           1 :       errorObj *ms_error = msGetErrorObj();
    8086             :       
    8087           1 :       switch(ms_error->code) {
    8088             :       case MS_NOERR:
    8089             :         break;
    8090           0 :       case MS_NOTFOUND:
    8091           0 :         msResetErrorList();
    8092           0 :         break;
    8093             :       case -1:
    8094             :         break;
    8095           0 :       case MS_IOERR:
    8096           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8097           0 :           _raise_ms_exception();
    8098           0 :           msResetErrorList();
    8099           0 :           return NULL;
    8100             :         }
    8101             :       default:
    8102           0 :         _raise_ms_exception();
    8103           0 :         msResetErrorList();
    8104           0 :         return NULL;
    8105             :       }
    8106             :       
    8107             :     }
    8108             :   }
    8109           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8110           1 :   free((char*)result);
    8111           1 :   return resultobj;
    8112           0 : fail:
    8113             :   return NULL;
    8114             : }
    8115             : 
    8116             : 
    8117           1 : SWIGINTERN PyObject *_wrap_new_clusterObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8118             :   PyObject *resultobj = 0;
    8119             :   clusterObj *result = 0 ;
    8120             :   
    8121           1 :   if (!PyArg_ParseTuple(args,(char *)":new_clusterObj")) SWIG_fail;
    8122             :   {
    8123           1 :     result = (clusterObj *)calloc(1, sizeof(clusterObj)); {
    8124           1 :       errorObj *ms_error = msGetErrorObj();
    8125             :       
    8126           1 :       switch(ms_error->code) {
    8127             :       case MS_NOERR:
    8128             :         break;
    8129           0 :       case MS_NOTFOUND:
    8130           0 :         msResetErrorList();
    8131           0 :         break;
    8132             :       case -1:
    8133             :         break;
    8134           0 :       case MS_IOERR:
    8135           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8136           0 :           _raise_ms_exception();
    8137           0 :           msResetErrorList();
    8138           0 :           return NULL;
    8139             :         }
    8140             :       default:
    8141           0 :         _raise_ms_exception();
    8142           0 :         msResetErrorList();
    8143           0 :         return NULL;
    8144             :       }
    8145             :       
    8146             :     }
    8147             :   }
    8148           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_clusterObj, SWIG_POINTER_NEW |  0 );
    8149           1 :   return resultobj;
    8150           1 : fail:
    8151             :   return NULL;
    8152             : }
    8153             : 
    8154             : 
    8155           1 : SWIGINTERN PyObject *_wrap_delete_clusterObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8156             :   PyObject *resultobj = 0;
    8157             :   clusterObj *arg1 = (clusterObj *) 0 ;
    8158           1 :   void *argp1 = 0 ;
    8159             :   int res1 = 0 ;
    8160           1 :   PyObject * obj0 = 0 ;
    8161             :   
    8162           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_clusterObj",&obj0)) SWIG_fail;
    8163           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, SWIG_POINTER_DISOWN |  0 );
    8164           1 :   if (!SWIG_IsOK(res1)) {
    8165           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_clusterObj" "', argument " "1"" of type '" "clusterObj *""'"); 
    8166             :   }
    8167           1 :   arg1 = (clusterObj *)(argp1);
    8168             :   {
    8169           1 :     free((char *) arg1); {
    8170           1 :       errorObj *ms_error = msGetErrorObj();
    8171             :       
    8172           1 :       switch(ms_error->code) {
    8173             :       case MS_NOERR:
    8174             :         break;
    8175           0 :       case MS_NOTFOUND:
    8176           0 :         msResetErrorList();
    8177           0 :         break;
    8178             :       case -1:
    8179             :         break;
    8180           0 :       case MS_IOERR:
    8181           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8182           0 :           _raise_ms_exception();
    8183           0 :           msResetErrorList();
    8184           0 :           return NULL;
    8185             :         }
    8186             :       default:
    8187           0 :         _raise_ms_exception();
    8188           0 :         msResetErrorList();
    8189           0 :         return NULL;
    8190             :       }
    8191             :       
    8192             :     }
    8193             :   }
    8194             :   resultobj = SWIG_Py_Void();
    8195           1 :   return resultobj;
    8196           0 : fail:
    8197             :   return NULL;
    8198             : }
    8199             : 
    8200             : 
    8201           1 : SWIGINTERN PyObject *clusterObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8202             :   PyObject *obj;
    8203           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    8204           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_clusterObj, SWIG_NewClientData(obj));
    8205           1 :   return SWIG_Py_Void();
    8206             : }
    8207             : 
    8208           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_numformatoptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8209             :   PyObject *resultobj = 0;
    8210             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8211           0 :   void *argp1 = 0 ;
    8212             :   int res1 = 0 ;
    8213           0 :   PyObject * obj0 = 0 ;
    8214             :   int result;
    8215             :   
    8216           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_numformatoptions_get",&obj0)) SWIG_fail;
    8217           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8218           0 :   if (!SWIG_IsOK(res1)) {
    8219           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_numformatoptions_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8220             :   }
    8221           0 :   arg1 = (outputFormatObj *)(argp1);
    8222           0 :   result = (int) ((arg1)->numformatoptions);
    8223             :   resultobj = SWIG_From_int((int)(result));
    8224           0 :   return resultobj;
    8225           0 : fail:
    8226             :   return NULL;
    8227             : }
    8228             : 
    8229             : 
    8230           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8231             :   PyObject *resultobj = 0;
    8232             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8233             :   char *arg2 = (char *) 0 ;
    8234           0 :   void *argp1 = 0 ;
    8235             :   int res1 = 0 ;
    8236             :   int res2 ;
    8237           0 :   char *buf2 = 0 ;
    8238           0 :   int alloc2 = 0 ;
    8239           0 :   PyObject * obj0 = 0 ;
    8240           0 :   PyObject * obj1 = 0 ;
    8241             :   
    8242           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_name_set",&obj0,&obj1)) SWIG_fail;
    8243           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8244           0 :   if (!SWIG_IsOK(res1)) {
    8245           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_name_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8246             :   }
    8247           0 :   arg1 = (outputFormatObj *)(argp1);
    8248           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8249           0 :   if (!SWIG_IsOK(res2)) {
    8250           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_name_set" "', argument " "2"" of type '" "char *""'");
    8251             :   }
    8252           0 :   arg2 = (char *)(buf2);
    8253             :   {
    8254           0 :     if (arg1->name) free((char*)arg1->name);
    8255           0 :     if (arg2) {
    8256           0 :       arg1->name = (char *) malloc(strlen(arg2)+1);
    8257             :       strcpy((char*)arg1->name,arg2);
    8258             :     } else {
    8259           0 :       arg1->name = 0;
    8260             :     }
    8261             :   }
    8262             :   resultobj = SWIG_Py_Void();
    8263           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8264             :   return resultobj;
    8265           0 : fail:
    8266           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8267             :   return NULL;
    8268             : }
    8269             : 
    8270             : 
    8271           1 : SWIGINTERN PyObject *_wrap_outputFormatObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8272             :   PyObject *resultobj = 0;
    8273             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8274           1 :   void *argp1 = 0 ;
    8275             :   int res1 = 0 ;
    8276           1 :   PyObject * obj0 = 0 ;
    8277             :   char *result = 0 ;
    8278             :   
    8279           1 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_name_get",&obj0)) SWIG_fail;
    8280           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8281           1 :   if (!SWIG_IsOK(res1)) {
    8282           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_name_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8283             :   }
    8284           1 :   arg1 = (outputFormatObj *)(argp1);
    8285           1 :   result = (char *) ((arg1)->name);
    8286           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8287           1 :   return resultobj;
    8288           0 : fail:
    8289             :   return NULL;
    8290             : }
    8291             : 
    8292             : 
    8293           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_mimetype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8294             :   PyObject *resultobj = 0;
    8295             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8296             :   char *arg2 = (char *) 0 ;
    8297           0 :   void *argp1 = 0 ;
    8298             :   int res1 = 0 ;
    8299             :   int res2 ;
    8300           0 :   char *buf2 = 0 ;
    8301           0 :   int alloc2 = 0 ;
    8302           0 :   PyObject * obj0 = 0 ;
    8303           0 :   PyObject * obj1 = 0 ;
    8304             :   
    8305           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_mimetype_set",&obj0,&obj1)) SWIG_fail;
    8306           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8307           0 :   if (!SWIG_IsOK(res1)) {
    8308           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_mimetype_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8309             :   }
    8310           0 :   arg1 = (outputFormatObj *)(argp1);
    8311           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8312           0 :   if (!SWIG_IsOK(res2)) {
    8313           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_mimetype_set" "', argument " "2"" of type '" "char *""'");
    8314             :   }
    8315           0 :   arg2 = (char *)(buf2);
    8316             :   {
    8317           0 :     if (arg1->mimetype) free((char*)arg1->mimetype);
    8318           0 :     if (arg2) {
    8319           0 :       arg1->mimetype = (char *) malloc(strlen(arg2)+1);
    8320             :       strcpy((char*)arg1->mimetype,arg2);
    8321             :     } else {
    8322           0 :       arg1->mimetype = 0;
    8323             :     }
    8324             :   }
    8325             :   resultobj = SWIG_Py_Void();
    8326           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8327             :   return resultobj;
    8328           0 : fail:
    8329           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8330             :   return NULL;
    8331             : }
    8332             : 
    8333             : 
    8334           1 : SWIGINTERN PyObject *_wrap_outputFormatObj_mimetype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8335             :   PyObject *resultobj = 0;
    8336             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8337           1 :   void *argp1 = 0 ;
    8338             :   int res1 = 0 ;
    8339           1 :   PyObject * obj0 = 0 ;
    8340             :   char *result = 0 ;
    8341             :   
    8342           1 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_mimetype_get",&obj0)) SWIG_fail;
    8343           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8344           1 :   if (!SWIG_IsOK(res1)) {
    8345           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_mimetype_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8346             :   }
    8347           1 :   arg1 = (outputFormatObj *)(argp1);
    8348           1 :   result = (char *) ((arg1)->mimetype);
    8349           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8350           1 :   return resultobj;
    8351           0 : fail:
    8352             :   return NULL;
    8353             : }
    8354             : 
    8355             : 
    8356           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_driver_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8357             :   PyObject *resultobj = 0;
    8358             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8359             :   char *arg2 = (char *) 0 ;
    8360           0 :   void *argp1 = 0 ;
    8361             :   int res1 = 0 ;
    8362             :   int res2 ;
    8363           0 :   char *buf2 = 0 ;
    8364           0 :   int alloc2 = 0 ;
    8365           0 :   PyObject * obj0 = 0 ;
    8366           0 :   PyObject * obj1 = 0 ;
    8367             :   
    8368           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_driver_set",&obj0,&obj1)) SWIG_fail;
    8369           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8370           0 :   if (!SWIG_IsOK(res1)) {
    8371           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_driver_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8372             :   }
    8373           0 :   arg1 = (outputFormatObj *)(argp1);
    8374           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8375           0 :   if (!SWIG_IsOK(res2)) {
    8376           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_driver_set" "', argument " "2"" of type '" "char *""'");
    8377             :   }
    8378           0 :   arg2 = (char *)(buf2);
    8379             :   {
    8380           0 :     if (arg1->driver) free((char*)arg1->driver);
    8381           0 :     if (arg2) {
    8382           0 :       arg1->driver = (char *) malloc(strlen(arg2)+1);
    8383             :       strcpy((char*)arg1->driver,arg2);
    8384             :     } else {
    8385           0 :       arg1->driver = 0;
    8386             :     }
    8387             :   }
    8388             :   resultobj = SWIG_Py_Void();
    8389           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8390             :   return resultobj;
    8391           0 : fail:
    8392           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8393             :   return NULL;
    8394             : }
    8395             : 
    8396             : 
    8397           1 : SWIGINTERN PyObject *_wrap_outputFormatObj_driver_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8398             :   PyObject *resultobj = 0;
    8399             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8400           1 :   void *argp1 = 0 ;
    8401             :   int res1 = 0 ;
    8402           1 :   PyObject * obj0 = 0 ;
    8403             :   char *result = 0 ;
    8404             :   
    8405           1 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_driver_get",&obj0)) SWIG_fail;
    8406           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8407           1 :   if (!SWIG_IsOK(res1)) {
    8408           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_driver_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8409             :   }
    8410           1 :   arg1 = (outputFormatObj *)(argp1);
    8411           1 :   result = (char *) ((arg1)->driver);
    8412           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8413           1 :   return resultobj;
    8414           0 : fail:
    8415             :   return NULL;
    8416             : }
    8417             : 
    8418             : 
    8419           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_extension_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8420             :   PyObject *resultobj = 0;
    8421             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8422             :   char *arg2 = (char *) 0 ;
    8423           0 :   void *argp1 = 0 ;
    8424             :   int res1 = 0 ;
    8425             :   int res2 ;
    8426           0 :   char *buf2 = 0 ;
    8427           0 :   int alloc2 = 0 ;
    8428           0 :   PyObject * obj0 = 0 ;
    8429           0 :   PyObject * obj1 = 0 ;
    8430             :   
    8431           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_extension_set",&obj0,&obj1)) SWIG_fail;
    8432           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8433           0 :   if (!SWIG_IsOK(res1)) {
    8434           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_extension_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8435             :   }
    8436           0 :   arg1 = (outputFormatObj *)(argp1);
    8437           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8438           0 :   if (!SWIG_IsOK(res2)) {
    8439           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_extension_set" "', argument " "2"" of type '" "char *""'");
    8440             :   }
    8441           0 :   arg2 = (char *)(buf2);
    8442             :   {
    8443           0 :     if (arg1->extension) free((char*)arg1->extension);
    8444           0 :     if (arg2) {
    8445           0 :       arg1->extension = (char *) malloc(strlen(arg2)+1);
    8446             :       strcpy((char*)arg1->extension,arg2);
    8447             :     } else {
    8448           0 :       arg1->extension = 0;
    8449             :     }
    8450             :   }
    8451             :   resultobj = SWIG_Py_Void();
    8452           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8453             :   return resultobj;
    8454           0 : fail:
    8455           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8456             :   return NULL;
    8457             : }
    8458             : 
    8459             : 
    8460           1 : SWIGINTERN PyObject *_wrap_outputFormatObj_extension_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8461             :   PyObject *resultobj = 0;
    8462             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8463           1 :   void *argp1 = 0 ;
    8464             :   int res1 = 0 ;
    8465           1 :   PyObject * obj0 = 0 ;
    8466             :   char *result = 0 ;
    8467             :   
    8468           1 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_extension_get",&obj0)) SWIG_fail;
    8469           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8470           1 :   if (!SWIG_IsOK(res1)) {
    8471           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_extension_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8472             :   }
    8473           1 :   arg1 = (outputFormatObj *)(argp1);
    8474           1 :   result = (char *) ((arg1)->extension);
    8475           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8476           1 :   return resultobj;
    8477           0 : fail:
    8478             :   return NULL;
    8479             : }
    8480             : 
    8481             : 
    8482           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_renderer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8483             :   PyObject *resultobj = 0;
    8484             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8485             :   int arg2 ;
    8486           0 :   void *argp1 = 0 ;
    8487             :   int res1 = 0 ;
    8488             :   int val2 ;
    8489             :   int ecode2 = 0 ;
    8490           0 :   PyObject * obj0 = 0 ;
    8491           0 :   PyObject * obj1 = 0 ;
    8492             :   
    8493           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_renderer_set",&obj0,&obj1)) SWIG_fail;
    8494           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8495           0 :   if (!SWIG_IsOK(res1)) {
    8496           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_renderer_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8497             :   }
    8498           0 :   arg1 = (outputFormatObj *)(argp1);
    8499           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    8500           0 :   if (!SWIG_IsOK(ecode2)) {
    8501           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_renderer_set" "', argument " "2"" of type '" "int""'");
    8502             :   } 
    8503             :   arg2 = (int)(val2);
    8504           0 :   if (arg1) (arg1)->renderer = arg2;
    8505             :   resultobj = SWIG_Py_Void();
    8506           0 :   return resultobj;
    8507           0 : fail:
    8508             :   return NULL;
    8509             : }
    8510             : 
    8511             : 
    8512           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_renderer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8513             :   PyObject *resultobj = 0;
    8514             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8515           0 :   void *argp1 = 0 ;
    8516             :   int res1 = 0 ;
    8517           0 :   PyObject * obj0 = 0 ;
    8518             :   int result;
    8519             :   
    8520           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_renderer_get",&obj0)) SWIG_fail;
    8521           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8522           0 :   if (!SWIG_IsOK(res1)) {
    8523           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_renderer_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8524             :   }
    8525           0 :   arg1 = (outputFormatObj *)(argp1);
    8526           0 :   result = (int) ((arg1)->renderer);
    8527             :   resultobj = SWIG_From_int((int)(result));
    8528           0 :   return resultobj;
    8529           0 : fail:
    8530             :   return NULL;
    8531             : }
    8532             : 
    8533             : 
    8534           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_imagemode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8535             :   PyObject *resultobj = 0;
    8536             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8537             :   int arg2 ;
    8538           0 :   void *argp1 = 0 ;
    8539             :   int res1 = 0 ;
    8540             :   int val2 ;
    8541             :   int ecode2 = 0 ;
    8542           0 :   PyObject * obj0 = 0 ;
    8543           0 :   PyObject * obj1 = 0 ;
    8544             :   
    8545           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_imagemode_set",&obj0,&obj1)) SWIG_fail;
    8546           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8547           0 :   if (!SWIG_IsOK(res1)) {
    8548           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_imagemode_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8549             :   }
    8550           0 :   arg1 = (outputFormatObj *)(argp1);
    8551           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    8552           0 :   if (!SWIG_IsOK(ecode2)) {
    8553           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_imagemode_set" "', argument " "2"" of type '" "int""'");
    8554             :   } 
    8555             :   arg2 = (int)(val2);
    8556           0 :   if (arg1) (arg1)->imagemode = arg2;
    8557             :   resultobj = SWIG_Py_Void();
    8558           0 :   return resultobj;
    8559           0 : fail:
    8560             :   return NULL;
    8561             : }
    8562             : 
    8563             : 
    8564           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_imagemode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8565             :   PyObject *resultobj = 0;
    8566             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8567           0 :   void *argp1 = 0 ;
    8568             :   int res1 = 0 ;
    8569           0 :   PyObject * obj0 = 0 ;
    8570             :   int result;
    8571             :   
    8572           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_imagemode_get",&obj0)) SWIG_fail;
    8573           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8574           0 :   if (!SWIG_IsOK(res1)) {
    8575           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_imagemode_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8576             :   }
    8577           0 :   arg1 = (outputFormatObj *)(argp1);
    8578           0 :   result = (int) ((arg1)->imagemode);
    8579             :   resultobj = SWIG_From_int((int)(result));
    8580           0 :   return resultobj;
    8581           0 : fail:
    8582             :   return NULL;
    8583             : }
    8584             : 
    8585             : 
    8586           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_transparent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8587             :   PyObject *resultobj = 0;
    8588             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8589             :   int arg2 ;
    8590           0 :   void *argp1 = 0 ;
    8591             :   int res1 = 0 ;
    8592             :   int val2 ;
    8593             :   int ecode2 = 0 ;
    8594           0 :   PyObject * obj0 = 0 ;
    8595           0 :   PyObject * obj1 = 0 ;
    8596             :   
    8597           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_transparent_set",&obj0,&obj1)) SWIG_fail;
    8598           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8599           0 :   if (!SWIG_IsOK(res1)) {
    8600           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_transparent_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8601             :   }
    8602           0 :   arg1 = (outputFormatObj *)(argp1);
    8603           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    8604           0 :   if (!SWIG_IsOK(ecode2)) {
    8605           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_transparent_set" "', argument " "2"" of type '" "int""'");
    8606             :   } 
    8607             :   arg2 = (int)(val2);
    8608           0 :   if (arg1) (arg1)->transparent = arg2;
    8609             :   resultobj = SWIG_Py_Void();
    8610           0 :   return resultobj;
    8611           0 : fail:
    8612             :   return NULL;
    8613             : }
    8614             : 
    8615             : 
    8616           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_transparent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8617             :   PyObject *resultobj = 0;
    8618             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8619           0 :   void *argp1 = 0 ;
    8620             :   int res1 = 0 ;
    8621           0 :   PyObject * obj0 = 0 ;
    8622             :   int result;
    8623             :   
    8624           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_transparent_get",&obj0)) SWIG_fail;
    8625           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8626           0 :   if (!SWIG_IsOK(res1)) {
    8627           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_transparent_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8628             :   }
    8629           0 :   arg1 = (outputFormatObj *)(argp1);
    8630           0 :   result = (int) ((arg1)->transparent);
    8631             :   resultobj = SWIG_From_int((int)(result));
    8632           0 :   return resultobj;
    8633           0 : fail:
    8634             :   return NULL;
    8635             : }
    8636             : 
    8637             : 
    8638           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_bands_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8639             :   PyObject *resultobj = 0;
    8640             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8641             :   int arg2 ;
    8642           0 :   void *argp1 = 0 ;
    8643             :   int res1 = 0 ;
    8644             :   int val2 ;
    8645             :   int ecode2 = 0 ;
    8646           0 :   PyObject * obj0 = 0 ;
    8647           0 :   PyObject * obj1 = 0 ;
    8648             :   
    8649           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_bands_set",&obj0,&obj1)) SWIG_fail;
    8650           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8651           0 :   if (!SWIG_IsOK(res1)) {
    8652           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_bands_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8653             :   }
    8654           0 :   arg1 = (outputFormatObj *)(argp1);
    8655           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    8656           0 :   if (!SWIG_IsOK(ecode2)) {
    8657           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_bands_set" "', argument " "2"" of type '" "int""'");
    8658             :   } 
    8659             :   arg2 = (int)(val2);
    8660           0 :   if (arg1) (arg1)->bands = arg2;
    8661             :   resultobj = SWIG_Py_Void();
    8662           0 :   return resultobj;
    8663           0 : fail:
    8664             :   return NULL;
    8665             : }
    8666             : 
    8667             : 
    8668           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_bands_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8669             :   PyObject *resultobj = 0;
    8670             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8671           0 :   void *argp1 = 0 ;
    8672             :   int res1 = 0 ;
    8673           0 :   PyObject * obj0 = 0 ;
    8674             :   int result;
    8675             :   
    8676           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_bands_get",&obj0)) SWIG_fail;
    8677           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8678           0 :   if (!SWIG_IsOK(res1)) {
    8679           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_bands_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8680             :   }
    8681           0 :   arg1 = (outputFormatObj *)(argp1);
    8682           0 :   result = (int) ((arg1)->bands);
    8683             :   resultobj = SWIG_From_int((int)(result));
    8684           0 :   return resultobj;
    8685           0 : fail:
    8686             :   return NULL;
    8687             : }
    8688             : 
    8689             : 
    8690           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_inmapfile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8691             :   PyObject *resultobj = 0;
    8692             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8693             :   int arg2 ;
    8694           0 :   void *argp1 = 0 ;
    8695             :   int res1 = 0 ;
    8696             :   int val2 ;
    8697             :   int ecode2 = 0 ;
    8698           0 :   PyObject * obj0 = 0 ;
    8699           0 :   PyObject * obj1 = 0 ;
    8700             :   
    8701           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_inmapfile_set",&obj0,&obj1)) SWIG_fail;
    8702           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8703           0 :   if (!SWIG_IsOK(res1)) {
    8704           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_inmapfile_set" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8705             :   }
    8706           0 :   arg1 = (outputFormatObj *)(argp1);
    8707           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    8708           0 :   if (!SWIG_IsOK(ecode2)) {
    8709           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_inmapfile_set" "', argument " "2"" of type '" "int""'");
    8710             :   } 
    8711             :   arg2 = (int)(val2);
    8712           0 :   if (arg1) (arg1)->inmapfile = arg2;
    8713             :   resultobj = SWIG_Py_Void();
    8714           0 :   return resultobj;
    8715           0 : fail:
    8716             :   return NULL;
    8717             : }
    8718             : 
    8719             : 
    8720           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_inmapfile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8721             :   PyObject *resultobj = 0;
    8722             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8723           0 :   void *argp1 = 0 ;
    8724             :   int res1 = 0 ;
    8725           0 :   PyObject * obj0 = 0 ;
    8726             :   int result;
    8727             :   
    8728           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_inmapfile_get",&obj0)) SWIG_fail;
    8729           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8730           0 :   if (!SWIG_IsOK(res1)) {
    8731           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_inmapfile_get" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8732             :   }
    8733           0 :   arg1 = (outputFormatObj *)(argp1);
    8734           0 :   result = (int) ((arg1)->inmapfile);
    8735             :   resultobj = SWIG_From_int((int)(result));
    8736           0 :   return resultobj;
    8737           0 : fail:
    8738             :   return NULL;
    8739             : }
    8740             : 
    8741             : 
    8742           1 : SWIGINTERN PyObject *_wrap_new_outputFormatObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8743             :   PyObject *resultobj = 0;
    8744             :   char *arg1 = (char *) 0 ;
    8745             :   char *arg2 = (char *) NULL ;
    8746             :   int res1 ;
    8747           1 :   char *buf1 = 0 ;
    8748           1 :   int alloc1 = 0 ;
    8749             :   int res2 ;
    8750           1 :   char *buf2 = 0 ;
    8751           1 :   int alloc2 = 0 ;
    8752           1 :   PyObject * obj0 = 0 ;
    8753           1 :   PyObject * obj1 = 0 ;
    8754             :   outputFormatObj *result = 0 ;
    8755             :   
    8756           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:new_outputFormatObj",&obj0,&obj1)) SWIG_fail;
    8757           1 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    8758           1 :   if (!SWIG_IsOK(res1)) {
    8759           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_outputFormatObj" "', argument " "1"" of type '" "char const *""'");
    8760             :   }
    8761           1 :   arg1 = (char *)(buf1);
    8762           1 :   if (obj1) {
    8763           1 :     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8764           1 :     if (!SWIG_IsOK(res2)) {
    8765           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_outputFormatObj" "', argument " "2"" of type '" "char *""'");
    8766             :     }
    8767           1 :     arg2 = (char *)(buf2);
    8768             :   }
    8769             :   {
    8770           1 :     result = (outputFormatObj *)new_outputFormatObj((char const *)arg1,arg2); {
    8771           1 :       errorObj *ms_error = msGetErrorObj();
    8772             :       
    8773           1 :       switch(ms_error->code) {
    8774             :       case MS_NOERR:
    8775             :         break;
    8776           0 :       case MS_NOTFOUND:
    8777           0 :         msResetErrorList();
    8778           0 :         break;
    8779             :       case -1:
    8780             :         break;
    8781           0 :       case MS_IOERR:
    8782           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8783           0 :           _raise_ms_exception();
    8784           0 :           msResetErrorList();
    8785           0 :           return NULL;
    8786             :         }
    8787             :       default:
    8788           1 :         _raise_ms_exception();
    8789           1 :         msResetErrorList();
    8790           1 :         return NULL;
    8791             :       }
    8792             :       
    8793             :     }
    8794             :   }
    8795           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, SWIG_POINTER_NEW |  0 );
    8796           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    8797           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8798             :   return resultobj;
    8799           0 : fail:
    8800           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    8801           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8802             :   return NULL;
    8803             : }
    8804             : 
    8805             : 
    8806           1 : SWIGINTERN PyObject *_wrap_delete_outputFormatObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8807             :   PyObject *resultobj = 0;
    8808             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8809           1 :   void *argp1 = 0 ;
    8810             :   int res1 = 0 ;
    8811           1 :   PyObject * obj0 = 0 ;
    8812             :   
    8813           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_outputFormatObj",&obj0)) SWIG_fail;
    8814           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, SWIG_POINTER_DISOWN |  0 );
    8815           1 :   if (!SWIG_IsOK(res1)) {
    8816           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_outputFormatObj" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8817             :   }
    8818           1 :   arg1 = (outputFormatObj *)(argp1);
    8819             :   {
    8820             :     delete_outputFormatObj(arg1); {
    8821           1 :       errorObj *ms_error = msGetErrorObj();
    8822             :       
    8823           1 :       switch(ms_error->code) {
    8824             :       case MS_NOERR:
    8825             :         break;
    8826           0 :       case MS_NOTFOUND:
    8827           0 :         msResetErrorList();
    8828           0 :         break;
    8829             :       case -1:
    8830             :         break;
    8831           0 :       case MS_IOERR:
    8832           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8833           0 :           _raise_ms_exception();
    8834           0 :           msResetErrorList();
    8835           0 :           return NULL;
    8836             :         }
    8837             :       default:
    8838           0 :         _raise_ms_exception();
    8839           0 :         msResetErrorList();
    8840           0 :         return NULL;
    8841             :       }
    8842             :       
    8843             :     }
    8844             :   }
    8845             :   resultobj = SWIG_Py_Void();
    8846           1 :   return resultobj;
    8847           0 : fail:
    8848             :   return NULL;
    8849             : }
    8850             : 
    8851             : 
    8852           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_setExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8853             :   PyObject *resultobj = 0;
    8854             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8855             :   char *arg2 = (char *) 0 ;
    8856           0 :   void *argp1 = 0 ;
    8857             :   int res1 = 0 ;
    8858             :   int res2 ;
    8859           0 :   char *buf2 = 0 ;
    8860           0 :   int alloc2 = 0 ;
    8861           0 :   PyObject * obj0 = 0 ;
    8862           0 :   PyObject * obj1 = 0 ;
    8863             :   
    8864           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_setExtension",&obj0,&obj1)) SWIG_fail;
    8865           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8866           0 :   if (!SWIG_IsOK(res1)) {
    8867           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_setExtension" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8868             :   }
    8869           0 :   arg1 = (outputFormatObj *)(argp1);
    8870           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8871           0 :   if (!SWIG_IsOK(res2)) {
    8872           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_setExtension" "', argument " "2"" of type '" "char const *""'");
    8873             :   }
    8874           0 :   arg2 = (char *)(buf2);
    8875             :   {
    8876             :     outputFormatObj_setExtension(arg1,(char const *)arg2); {
    8877           0 :       errorObj *ms_error = msGetErrorObj();
    8878             :       
    8879           0 :       switch(ms_error->code) {
    8880             :       case MS_NOERR:
    8881             :         break;
    8882           0 :       case MS_NOTFOUND:
    8883           0 :         msResetErrorList();
    8884           0 :         break;
    8885             :       case -1:
    8886             :         break;
    8887           0 :       case MS_IOERR:
    8888           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8889           0 :           _raise_ms_exception();
    8890           0 :           msResetErrorList();
    8891           0 :           return NULL;
    8892             :         }
    8893             :       default:
    8894           0 :         _raise_ms_exception();
    8895           0 :         msResetErrorList();
    8896           0 :         return NULL;
    8897             :       }
    8898             :       
    8899             :     }
    8900             :   }
    8901             :   resultobj = SWIG_Py_Void();
    8902           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8903             :   return resultobj;
    8904           0 : fail:
    8905           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8906             :   return NULL;
    8907             : }
    8908             : 
    8909             : 
    8910           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_setMimetype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8911             :   PyObject *resultobj = 0;
    8912             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8913             :   char *arg2 = (char *) 0 ;
    8914           0 :   void *argp1 = 0 ;
    8915             :   int res1 = 0 ;
    8916             :   int res2 ;
    8917           0 :   char *buf2 = 0 ;
    8918           0 :   int alloc2 = 0 ;
    8919           0 :   PyObject * obj0 = 0 ;
    8920           0 :   PyObject * obj1 = 0 ;
    8921             :   
    8922           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_setMimetype",&obj0,&obj1)) SWIG_fail;
    8923           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8924           0 :   if (!SWIG_IsOK(res1)) {
    8925           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_setMimetype" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8926             :   }
    8927           0 :   arg1 = (outputFormatObj *)(argp1);
    8928           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8929           0 :   if (!SWIG_IsOK(res2)) {
    8930           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_setMimetype" "', argument " "2"" of type '" "char const *""'");
    8931             :   }
    8932           0 :   arg2 = (char *)(buf2);
    8933             :   {
    8934             :     outputFormatObj_setMimetype(arg1,(char const *)arg2); {
    8935           0 :       errorObj *ms_error = msGetErrorObj();
    8936             :       
    8937           0 :       switch(ms_error->code) {
    8938             :       case MS_NOERR:
    8939             :         break;
    8940           0 :       case MS_NOTFOUND:
    8941           0 :         msResetErrorList();
    8942           0 :         break;
    8943             :       case -1:
    8944             :         break;
    8945           0 :       case MS_IOERR:
    8946           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    8947           0 :           _raise_ms_exception();
    8948           0 :           msResetErrorList();
    8949           0 :           return NULL;
    8950             :         }
    8951             :       default:
    8952           0 :         _raise_ms_exception();
    8953           0 :         msResetErrorList();
    8954           0 :         return NULL;
    8955             :       }
    8956             :       
    8957             :     }
    8958             :   }
    8959             :   resultobj = SWIG_Py_Void();
    8960           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8961             :   return resultobj;
    8962           0 : fail:
    8963           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    8964             :   return NULL;
    8965             : }
    8966             : 
    8967             : 
    8968           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_setOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8969             :   PyObject *resultobj = 0;
    8970             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    8971             :   char *arg2 = (char *) 0 ;
    8972             :   char *arg3 = (char *) 0 ;
    8973           0 :   void *argp1 = 0 ;
    8974             :   int res1 = 0 ;
    8975             :   int res2 ;
    8976           0 :   char *buf2 = 0 ;
    8977           0 :   int alloc2 = 0 ;
    8978             :   int res3 ;
    8979           0 :   char *buf3 = 0 ;
    8980           0 :   int alloc3 = 0 ;
    8981           0 :   PyObject * obj0 = 0 ;
    8982           0 :   PyObject * obj1 = 0 ;
    8983           0 :   PyObject * obj2 = 0 ;
    8984             :   
    8985           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:outputFormatObj_setOption",&obj0,&obj1,&obj2)) SWIG_fail;
    8986           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    8987           0 :   if (!SWIG_IsOK(res1)) {
    8988           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_setOption" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    8989             :   }
    8990           0 :   arg1 = (outputFormatObj *)(argp1);
    8991           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8992           0 :   if (!SWIG_IsOK(res2)) {
    8993           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_setOption" "', argument " "2"" of type '" "char const *""'");
    8994             :   }
    8995           0 :   arg2 = (char *)(buf2);
    8996           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
    8997           0 :   if (!SWIG_IsOK(res3)) {
    8998           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "outputFormatObj_setOption" "', argument " "3"" of type '" "char const *""'");
    8999             :   }
    9000           0 :   arg3 = (char *)(buf3);
    9001             :   {
    9002             :     outputFormatObj_setOption(arg1,(char const *)arg2,(char const *)arg3); {
    9003           0 :       errorObj *ms_error = msGetErrorObj();
    9004             :       
    9005           0 :       switch(ms_error->code) {
    9006             :       case MS_NOERR:
    9007             :         break;
    9008           0 :       case MS_NOTFOUND:
    9009           0 :         msResetErrorList();
    9010           0 :         break;
    9011             :       case -1:
    9012             :         break;
    9013           0 :       case MS_IOERR:
    9014           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9015           0 :           _raise_ms_exception();
    9016           0 :           msResetErrorList();
    9017           0 :           return NULL;
    9018             :         }
    9019             :       default:
    9020           0 :         _raise_ms_exception();
    9021           0 :         msResetErrorList();
    9022           0 :         return NULL;
    9023             :       }
    9024             :       
    9025             :     }
    9026             :   }
    9027             :   resultobj = SWIG_Py_Void();
    9028           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9029           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
    9030             :   return resultobj;
    9031           0 : fail:
    9032           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9033           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
    9034             :   return NULL;
    9035             : }
    9036             : 
    9037             : 
    9038           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9039             :   PyObject *resultobj = 0;
    9040             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    9041           0 :   void *argp1 = 0 ;
    9042             :   int res1 = 0 ;
    9043           0 :   PyObject * obj0 = 0 ;
    9044             :   int result;
    9045             :   
    9046           0 :   if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_validate",&obj0)) SWIG_fail;
    9047           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    9048           0 :   if (!SWIG_IsOK(res1)) {
    9049           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_validate" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    9050             :   }
    9051           0 :   arg1 = (outputFormatObj *)(argp1);
    9052             :   {
    9053             :     result = (int)outputFormatObj_validate(arg1); {
    9054           0 :       errorObj *ms_error = msGetErrorObj();
    9055             :       
    9056           0 :       switch(ms_error->code) {
    9057             :       case MS_NOERR:
    9058             :         break;
    9059           0 :       case MS_NOTFOUND:
    9060           0 :         msResetErrorList();
    9061           0 :         break;
    9062             :       case -1:
    9063             :         break;
    9064           0 :       case MS_IOERR:
    9065           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9066           0 :           _raise_ms_exception();
    9067           0 :           msResetErrorList();
    9068           0 :           return NULL;
    9069             :         }
    9070             :       default:
    9071           0 :         _raise_ms_exception();
    9072           0 :         msResetErrorList();
    9073           0 :         return NULL;
    9074             :       }
    9075             :       
    9076             :     }
    9077             :   }
    9078             :   resultobj = SWIG_From_int((int)(result));
    9079           0 :   return resultobj;
    9080           0 : fail:
    9081             :   return NULL;
    9082             : }
    9083             : 
    9084             : 
    9085           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_getOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9086             :   PyObject *resultobj = 0;
    9087             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    9088             :   char *arg2 = (char *) 0 ;
    9089             :   char *arg3 = (char *) "" ;
    9090           0 :   void *argp1 = 0 ;
    9091             :   int res1 = 0 ;
    9092             :   int res2 ;
    9093           0 :   char *buf2 = 0 ;
    9094           0 :   int alloc2 = 0 ;
    9095             :   int res3 ;
    9096           0 :   char *buf3 = 0 ;
    9097           0 :   int alloc3 = 0 ;
    9098           0 :   PyObject * obj0 = 0 ;
    9099           0 :   PyObject * obj1 = 0 ;
    9100           0 :   PyObject * obj2 = 0 ;
    9101             :   char *result = 0 ;
    9102             :   
    9103           0 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:outputFormatObj_getOption",&obj0,&obj1,&obj2)) SWIG_fail;
    9104           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    9105           0 :   if (!SWIG_IsOK(res1)) {
    9106           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_getOption" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    9107             :   }
    9108           0 :   arg1 = (outputFormatObj *)(argp1);
    9109           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9110           0 :   if (!SWIG_IsOK(res2)) {
    9111           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_getOption" "', argument " "2"" of type '" "char const *""'");
    9112             :   }
    9113           0 :   arg2 = (char *)(buf2);
    9114           0 :   if (obj2) {
    9115           0 :     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
    9116           0 :     if (!SWIG_IsOK(res3)) {
    9117           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "outputFormatObj_getOption" "', argument " "3"" of type '" "char const *""'");
    9118             :     }
    9119           0 :     arg3 = (char *)(buf3);
    9120             :   }
    9121             :   {
    9122             :     result = (char *)outputFormatObj_getOption(arg1,(char const *)arg2,(char const *)arg3); {
    9123           0 :       errorObj *ms_error = msGetErrorObj();
    9124             :       
    9125           0 :       switch(ms_error->code) {
    9126             :       case MS_NOERR:
    9127             :         break;
    9128           0 :       case MS_NOTFOUND:
    9129           0 :         msResetErrorList();
    9130           0 :         break;
    9131             :       case -1:
    9132             :         break;
    9133           0 :       case MS_IOERR:
    9134           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9135           0 :           _raise_ms_exception();
    9136           0 :           msResetErrorList();
    9137           0 :           return NULL;
    9138             :         }
    9139             :       default:
    9140           0 :         _raise_ms_exception();
    9141           0 :         msResetErrorList();
    9142           0 :         return NULL;
    9143             :       }
    9144             :       
    9145             :     }
    9146             :   }
    9147           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9148           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9149           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
    9150           0 :   free((char*)result);
    9151           0 :   return resultobj;
    9152           0 : fail:
    9153           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9154           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
    9155             :   return NULL;
    9156             : }
    9157             : 
    9158             : 
    9159           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_getOptionAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9160             :   PyObject *resultobj = 0;
    9161             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    9162             :   int arg2 ;
    9163           0 :   void *argp1 = 0 ;
    9164             :   int res1 = 0 ;
    9165             :   int val2 ;
    9166             :   int ecode2 = 0 ;
    9167           0 :   PyObject * obj0 = 0 ;
    9168           0 :   PyObject * obj1 = 0 ;
    9169             :   char *result = 0 ;
    9170             :   
    9171           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_getOptionAt",&obj0,&obj1)) SWIG_fail;
    9172           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    9173           0 :   if (!SWIG_IsOK(res1)) {
    9174           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_getOptionAt" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    9175             :   }
    9176           0 :   arg1 = (outputFormatObj *)(argp1);
    9177           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9178           0 :   if (!SWIG_IsOK(ecode2)) {
    9179           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_getOptionAt" "', argument " "2"" of type '" "int""'");
    9180             :   } 
    9181             :   arg2 = (int)(val2);
    9182             :   {
    9183             :     result = (char *)outputFormatObj_getOptionAt(arg1,arg2); {
    9184           0 :       errorObj *ms_error = msGetErrorObj();
    9185             :       
    9186           0 :       switch(ms_error->code) {
    9187             :       case MS_NOERR:
    9188             :         break;
    9189           0 :       case MS_NOTFOUND:
    9190           0 :         msResetErrorList();
    9191           0 :         break;
    9192             :       case -1:
    9193             :         break;
    9194           0 :       case MS_IOERR:
    9195           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9196           0 :           _raise_ms_exception();
    9197           0 :           msResetErrorList();
    9198           0 :           return NULL;
    9199             :         }
    9200             :       default:
    9201           0 :         _raise_ms_exception();
    9202           0 :         msResetErrorList();
    9203           0 :         return NULL;
    9204             :       }
    9205             :       
    9206             :     }
    9207             :   }
    9208           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9209           0 :   free((char*)result);
    9210           0 :   return resultobj;
    9211           0 : fail:
    9212             :   return NULL;
    9213             : }
    9214             : 
    9215             : 
    9216           0 : SWIGINTERN PyObject *_wrap_outputFormatObj_attachDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9217             :   PyObject *resultobj = 0;
    9218             :   outputFormatObj *arg1 = (outputFormatObj *) 0 ;
    9219           0 :   void *arg2 = (void *) 0 ;
    9220           0 :   void *argp1 = 0 ;
    9221             :   int res1 = 0 ;
    9222             :   int res2 ;
    9223           0 :   PyObject * obj0 = 0 ;
    9224           0 :   PyObject * obj1 = 0 ;
    9225             :   
    9226           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_attachDevice",&obj0,&obj1)) SWIG_fail;
    9227           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 |  0 );
    9228           0 :   if (!SWIG_IsOK(res1)) {
    9229           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_attachDevice" "', argument " "1"" of type '" "outputFormatObj *""'"); 
    9230             :   }
    9231           0 :   arg1 = (outputFormatObj *)(argp1);
    9232           0 :   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    9233           0 :   if (!SWIG_IsOK(res2)) {
    9234           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_attachDevice" "', argument " "2"" of type '" "void *""'"); 
    9235             :   }
    9236             :   {
    9237           0 :     outputFormatObj_attachDevice(arg1,arg2); {
    9238           0 :       errorObj *ms_error = msGetErrorObj();
    9239             :       
    9240           0 :       switch(ms_error->code) {
    9241             :       case MS_NOERR:
    9242             :         break;
    9243           0 :       case MS_NOTFOUND:
    9244           0 :         msResetErrorList();
    9245           0 :         break;
    9246             :       case -1:
    9247             :         break;
    9248           0 :       case MS_IOERR:
    9249           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9250           0 :           _raise_ms_exception();
    9251           0 :           msResetErrorList();
    9252           0 :           return NULL;
    9253             :         }
    9254             :       default:
    9255           0 :         _raise_ms_exception();
    9256           0 :         msResetErrorList();
    9257           0 :         return NULL;
    9258             :       }
    9259             :       
    9260             :     }
    9261             :   }
    9262             :   resultobj = SWIG_Py_Void();
    9263           0 :   return resultobj;
    9264           0 : fail:
    9265             :   return NULL;
    9266             : }
    9267             : 
    9268             : 
    9269           1 : SWIGINTERN PyObject *outputFormatObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9270             :   PyObject *obj;
    9271           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    9272           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_outputFormatObj, SWIG_NewClientData(obj));
    9273           1 :   return SWIG_Py_Void();
    9274             : }
    9275             : 
    9276           0 : SWIGINTERN PyObject *_wrap_queryMapObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9277             :   PyObject *resultobj = 0;
    9278             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9279             :   int arg2 ;
    9280           0 :   void *argp1 = 0 ;
    9281             :   int res1 = 0 ;
    9282             :   int val2 ;
    9283             :   int ecode2 = 0 ;
    9284           0 :   PyObject * obj0 = 0 ;
    9285           0 :   PyObject * obj1 = 0 ;
    9286             :   
    9287           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_height_set",&obj0,&obj1)) SWIG_fail;
    9288           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9289           0 :   if (!SWIG_IsOK(res1)) {
    9290           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_height_set" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9291             :   }
    9292           0 :   arg1 = (queryMapObj *)(argp1);
    9293           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9294           0 :   if (!SWIG_IsOK(ecode2)) {
    9295           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_height_set" "', argument " "2"" of type '" "int""'");
    9296             :   } 
    9297             :   arg2 = (int)(val2);
    9298           0 :   if (arg1) (arg1)->height = arg2;
    9299             :   resultobj = SWIG_Py_Void();
    9300           0 :   return resultobj;
    9301           0 : fail:
    9302             :   return NULL;
    9303             : }
    9304             : 
    9305             : 
    9306           0 : SWIGINTERN PyObject *_wrap_queryMapObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9307             :   PyObject *resultobj = 0;
    9308             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9309           0 :   void *argp1 = 0 ;
    9310             :   int res1 = 0 ;
    9311           0 :   PyObject * obj0 = 0 ;
    9312             :   int result;
    9313             :   
    9314           0 :   if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_height_get",&obj0)) SWIG_fail;
    9315           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9316           0 :   if (!SWIG_IsOK(res1)) {
    9317           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_height_get" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9318             :   }
    9319           0 :   arg1 = (queryMapObj *)(argp1);
    9320           0 :   result = (int) ((arg1)->height);
    9321             :   resultobj = SWIG_From_int((int)(result));
    9322           0 :   return resultobj;
    9323           0 : fail:
    9324             :   return NULL;
    9325             : }
    9326             : 
    9327             : 
    9328           0 : SWIGINTERN PyObject *_wrap_queryMapObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9329             :   PyObject *resultobj = 0;
    9330             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9331             :   int arg2 ;
    9332           0 :   void *argp1 = 0 ;
    9333             :   int res1 = 0 ;
    9334             :   int val2 ;
    9335             :   int ecode2 = 0 ;
    9336           0 :   PyObject * obj0 = 0 ;
    9337           0 :   PyObject * obj1 = 0 ;
    9338             :   
    9339           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_width_set",&obj0,&obj1)) SWIG_fail;
    9340           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9341           0 :   if (!SWIG_IsOK(res1)) {
    9342           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_width_set" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9343             :   }
    9344           0 :   arg1 = (queryMapObj *)(argp1);
    9345           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9346           0 :   if (!SWIG_IsOK(ecode2)) {
    9347           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_width_set" "', argument " "2"" of type '" "int""'");
    9348             :   } 
    9349             :   arg2 = (int)(val2);
    9350           0 :   if (arg1) (arg1)->width = arg2;
    9351             :   resultobj = SWIG_Py_Void();
    9352           0 :   return resultobj;
    9353           0 : fail:
    9354             :   return NULL;
    9355             : }
    9356             : 
    9357             : 
    9358           0 : SWIGINTERN PyObject *_wrap_queryMapObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9359             :   PyObject *resultobj = 0;
    9360             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9361           0 :   void *argp1 = 0 ;
    9362             :   int res1 = 0 ;
    9363           0 :   PyObject * obj0 = 0 ;
    9364             :   int result;
    9365             :   
    9366           0 :   if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_width_get",&obj0)) SWIG_fail;
    9367           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9368           0 :   if (!SWIG_IsOK(res1)) {
    9369           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_width_get" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9370             :   }
    9371           0 :   arg1 = (queryMapObj *)(argp1);
    9372           0 :   result = (int) ((arg1)->width);
    9373             :   resultobj = SWIG_From_int((int)(result));
    9374           0 :   return resultobj;
    9375           0 : fail:
    9376             :   return NULL;
    9377             : }
    9378             : 
    9379             : 
    9380           0 : SWIGINTERN PyObject *_wrap_queryMapObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9381             :   PyObject *resultobj = 0;
    9382             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9383             :   int arg2 ;
    9384           0 :   void *argp1 = 0 ;
    9385             :   int res1 = 0 ;
    9386             :   int val2 ;
    9387             :   int ecode2 = 0 ;
    9388           0 :   PyObject * obj0 = 0 ;
    9389           0 :   PyObject * obj1 = 0 ;
    9390             :   
    9391           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_status_set",&obj0,&obj1)) SWIG_fail;
    9392           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9393           0 :   if (!SWIG_IsOK(res1)) {
    9394           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_status_set" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9395             :   }
    9396           0 :   arg1 = (queryMapObj *)(argp1);
    9397           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9398           0 :   if (!SWIG_IsOK(ecode2)) {
    9399           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_status_set" "', argument " "2"" of type '" "int""'");
    9400             :   } 
    9401             :   arg2 = (int)(val2);
    9402           0 :   if (arg1) (arg1)->status = arg2;
    9403             :   resultobj = SWIG_Py_Void();
    9404           0 :   return resultobj;
    9405           0 : fail:
    9406             :   return NULL;
    9407             : }
    9408             : 
    9409             : 
    9410           0 : SWIGINTERN PyObject *_wrap_queryMapObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9411             :   PyObject *resultobj = 0;
    9412             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9413           0 :   void *argp1 = 0 ;
    9414             :   int res1 = 0 ;
    9415           0 :   PyObject * obj0 = 0 ;
    9416             :   int result;
    9417             :   
    9418           0 :   if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_status_get",&obj0)) SWIG_fail;
    9419           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9420           0 :   if (!SWIG_IsOK(res1)) {
    9421           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_status_get" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9422             :   }
    9423           0 :   arg1 = (queryMapObj *)(argp1);
    9424           0 :   result = (int) ((arg1)->status);
    9425             :   resultobj = SWIG_From_int((int)(result));
    9426           0 :   return resultobj;
    9427           0 : fail:
    9428             :   return NULL;
    9429             : }
    9430             : 
    9431             : 
    9432           0 : SWIGINTERN PyObject *_wrap_queryMapObj_style_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9433             :   PyObject *resultobj = 0;
    9434             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9435             :   int arg2 ;
    9436           0 :   void *argp1 = 0 ;
    9437             :   int res1 = 0 ;
    9438             :   int val2 ;
    9439             :   int ecode2 = 0 ;
    9440           0 :   PyObject * obj0 = 0 ;
    9441           0 :   PyObject * obj1 = 0 ;
    9442             :   
    9443           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_style_set",&obj0,&obj1)) SWIG_fail;
    9444           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9445           0 :   if (!SWIG_IsOK(res1)) {
    9446           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_style_set" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9447             :   }
    9448           0 :   arg1 = (queryMapObj *)(argp1);
    9449           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9450           0 :   if (!SWIG_IsOK(ecode2)) {
    9451           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_style_set" "', argument " "2"" of type '" "int""'");
    9452             :   } 
    9453             :   arg2 = (int)(val2);
    9454           0 :   if (arg1) (arg1)->style = arg2;
    9455             :   resultobj = SWIG_Py_Void();
    9456           0 :   return resultobj;
    9457           0 : fail:
    9458             :   return NULL;
    9459             : }
    9460             : 
    9461             : 
    9462           0 : SWIGINTERN PyObject *_wrap_queryMapObj_style_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9463             :   PyObject *resultobj = 0;
    9464             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9465           0 :   void *argp1 = 0 ;
    9466             :   int res1 = 0 ;
    9467           0 :   PyObject * obj0 = 0 ;
    9468             :   int result;
    9469             :   
    9470           0 :   if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_style_get",&obj0)) SWIG_fail;
    9471           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9472           0 :   if (!SWIG_IsOK(res1)) {
    9473           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_style_get" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9474             :   }
    9475           0 :   arg1 = (queryMapObj *)(argp1);
    9476           0 :   result = (int) ((arg1)->style);
    9477             :   resultobj = SWIG_From_int((int)(result));
    9478           0 :   return resultobj;
    9479           0 : fail:
    9480             :   return NULL;
    9481             : }
    9482             : 
    9483             : 
    9484           0 : SWIGINTERN PyObject *_wrap_queryMapObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9485             :   PyObject *resultobj = 0;
    9486             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9487             :   colorObj *arg2 = (colorObj *) 0 ;
    9488           0 :   void *argp1 = 0 ;
    9489             :   int res1 = 0 ;
    9490           0 :   void *argp2 = 0 ;
    9491             :   int res2 = 0 ;
    9492           0 :   PyObject * obj0 = 0 ;
    9493           0 :   PyObject * obj1 = 0 ;
    9494             :   
    9495           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_color_set",&obj0,&obj1)) SWIG_fail;
    9496           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9497           0 :   if (!SWIG_IsOK(res1)) {
    9498           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_color_set" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9499             :   }
    9500           0 :   arg1 = (queryMapObj *)(argp1);
    9501           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
    9502           0 :   if (!SWIG_IsOK(res2)) {
    9503           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "queryMapObj_color_set" "', argument " "2"" of type '" "colorObj *""'"); 
    9504             :   }
    9505           0 :   arg2 = (colorObj *)(argp2);
    9506           0 :   if (arg1) (arg1)->color = *arg2;
    9507             :   resultobj = SWIG_Py_Void();
    9508           0 :   return resultobj;
    9509           0 : fail:
    9510             :   return NULL;
    9511             : }
    9512             : 
    9513             : 
    9514           0 : SWIGINTERN PyObject *_wrap_queryMapObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9515             :   PyObject *resultobj = 0;
    9516             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9517           0 :   void *argp1 = 0 ;
    9518             :   int res1 = 0 ;
    9519           0 :   PyObject * obj0 = 0 ;
    9520             :   colorObj *result = 0 ;
    9521             :   
    9522           0 :   if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_color_get",&obj0)) SWIG_fail;
    9523           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9524           0 :   if (!SWIG_IsOK(res1)) {
    9525           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_color_get" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9526             :   }
    9527           0 :   arg1 = (queryMapObj *)(argp1);
    9528           0 :   result = (colorObj *)& ((arg1)->color);
    9529           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
    9530           0 :   return resultobj;
    9531           0 : fail:
    9532             :   return NULL;
    9533             : }
    9534             : 
    9535             : 
    9536           0 : SWIGINTERN PyObject *_wrap_queryMapObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9537             :   PyObject *resultobj = 0;
    9538             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9539             :   char *arg2 = (char *) 0 ;
    9540           0 :   void *argp1 = 0 ;
    9541             :   int res1 = 0 ;
    9542             :   int res2 ;
    9543           0 :   char *buf2 = 0 ;
    9544           0 :   int alloc2 = 0 ;
    9545           0 :   PyObject * obj0 = 0 ;
    9546           0 :   PyObject * obj1 = 0 ;
    9547             :   int result;
    9548             :   
    9549           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_updateFromString",&obj0,&obj1)) SWIG_fail;
    9550           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9551           0 :   if (!SWIG_IsOK(res1)) {
    9552           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_updateFromString" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9553             :   }
    9554           0 :   arg1 = (queryMapObj *)(argp1);
    9555           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9556           0 :   if (!SWIG_IsOK(res2)) {
    9557           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "queryMapObj_updateFromString" "', argument " "2"" of type '" "char *""'");
    9558             :   }
    9559           0 :   arg2 = (char *)(buf2);
    9560             :   {
    9561             :     result = (int)queryMapObj_updateFromString(arg1,arg2); {
    9562           0 :       errorObj *ms_error = msGetErrorObj();
    9563             :       
    9564           0 :       switch(ms_error->code) {
    9565             :       case MS_NOERR:
    9566             :         break;
    9567           0 :       case MS_NOTFOUND:
    9568           0 :         msResetErrorList();
    9569           0 :         break;
    9570             :       case -1:
    9571             :         break;
    9572           0 :       case MS_IOERR:
    9573           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9574           0 :           _raise_ms_exception();
    9575           0 :           msResetErrorList();
    9576           0 :           return NULL;
    9577             :         }
    9578             :       default:
    9579           0 :         _raise_ms_exception();
    9580           0 :         msResetErrorList();
    9581           0 :         return NULL;
    9582             :       }
    9583             :       
    9584             :     }
    9585             :   }
    9586             :   resultobj = SWIG_From_int((int)(result));
    9587           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9588             :   return resultobj;
    9589           0 : fail:
    9590           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9591             :   return NULL;
    9592             : }
    9593             : 
    9594             : 
    9595           0 : SWIGINTERN PyObject *_wrap_queryMapObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9596             :   PyObject *resultobj = 0;
    9597             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9598           0 :   void *argp1 = 0 ;
    9599             :   int res1 = 0 ;
    9600           0 :   PyObject * obj0 = 0 ;
    9601             :   char *result = 0 ;
    9602             :   
    9603           0 :   if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_convertToString",&obj0)) SWIG_fail;
    9604           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 |  0 );
    9605           0 :   if (!SWIG_IsOK(res1)) {
    9606           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_convertToString" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9607             :   }
    9608           0 :   arg1 = (queryMapObj *)(argp1);
    9609             :   {
    9610             :     result = (char *)queryMapObj_convertToString(arg1); {
    9611           0 :       errorObj *ms_error = msGetErrorObj();
    9612             :       
    9613           0 :       switch(ms_error->code) {
    9614             :       case MS_NOERR:
    9615             :         break;
    9616           0 :       case MS_NOTFOUND:
    9617           0 :         msResetErrorList();
    9618           0 :         break;
    9619             :       case -1:
    9620             :         break;
    9621           0 :       case MS_IOERR:
    9622           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9623           0 :           _raise_ms_exception();
    9624           0 :           msResetErrorList();
    9625           0 :           return NULL;
    9626             :         }
    9627             :       default:
    9628           0 :         _raise_ms_exception();
    9629           0 :         msResetErrorList();
    9630           0 :         return NULL;
    9631             :       }
    9632             :       
    9633             :     }
    9634             :   }
    9635           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9636           0 :   free((char*)result);
    9637           0 :   return resultobj;
    9638           0 : fail:
    9639             :   return NULL;
    9640             : }
    9641             : 
    9642             : 
    9643           0 : SWIGINTERN PyObject *_wrap_new_queryMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9644             :   PyObject *resultobj = 0;
    9645             :   queryMapObj *result = 0 ;
    9646             :   
    9647           0 :   if (!PyArg_ParseTuple(args,(char *)":new_queryMapObj")) SWIG_fail;
    9648             :   {
    9649           0 :     result = (queryMapObj *)calloc(1, sizeof(queryMapObj)); {
    9650           0 :       errorObj *ms_error = msGetErrorObj();
    9651             :       
    9652           0 :       switch(ms_error->code) {
    9653             :       case MS_NOERR:
    9654             :         break;
    9655           0 :       case MS_NOTFOUND:
    9656           0 :         msResetErrorList();
    9657           0 :         break;
    9658             :       case -1:
    9659             :         break;
    9660           0 :       case MS_IOERR:
    9661           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9662           0 :           _raise_ms_exception();
    9663           0 :           msResetErrorList();
    9664           0 :           return NULL;
    9665             :         }
    9666             :       default:
    9667           0 :         _raise_ms_exception();
    9668           0 :         msResetErrorList();
    9669           0 :         return NULL;
    9670             :       }
    9671             :       
    9672             :     }
    9673             :   }
    9674           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_queryMapObj, SWIG_POINTER_NEW |  0 );
    9675           0 :   return resultobj;
    9676           0 : fail:
    9677             :   return NULL;
    9678             : }
    9679             : 
    9680             : 
    9681           0 : SWIGINTERN PyObject *_wrap_delete_queryMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9682             :   PyObject *resultobj = 0;
    9683             :   queryMapObj *arg1 = (queryMapObj *) 0 ;
    9684           0 :   void *argp1 = 0 ;
    9685             :   int res1 = 0 ;
    9686           0 :   PyObject * obj0 = 0 ;
    9687             :   
    9688           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_queryMapObj",&obj0)) SWIG_fail;
    9689           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, SWIG_POINTER_DISOWN |  0 );
    9690           0 :   if (!SWIG_IsOK(res1)) {
    9691           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_queryMapObj" "', argument " "1"" of type '" "queryMapObj *""'"); 
    9692             :   }
    9693           0 :   arg1 = (queryMapObj *)(argp1);
    9694             :   {
    9695           0 :     free((char *) arg1); {
    9696           0 :       errorObj *ms_error = msGetErrorObj();
    9697             :       
    9698           0 :       switch(ms_error->code) {
    9699             :       case MS_NOERR:
    9700             :         break;
    9701           0 :       case MS_NOTFOUND:
    9702           0 :         msResetErrorList();
    9703           0 :         break;
    9704             :       case -1:
    9705             :         break;
    9706           0 :       case MS_IOERR:
    9707           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
    9708           0 :           _raise_ms_exception();
    9709           0 :           msResetErrorList();
    9710           0 :           return NULL;
    9711             :         }
    9712             :       default:
    9713           0 :         _raise_ms_exception();
    9714           0 :         msResetErrorList();
    9715           0 :         return NULL;
    9716             :       }
    9717             :       
    9718             :     }
    9719             :   }
    9720             :   resultobj = SWIG_Py_Void();
    9721           0 :   return resultobj;
    9722           0 : fail:
    9723             :   return NULL;
    9724             : }
    9725             : 
    9726             : 
    9727           1 : SWIGINTERN PyObject *queryMapObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9728             :   PyObject *obj;
    9729           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    9730           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_queryMapObj, SWIG_NewClientData(obj));
    9731           1 :   return SWIG_Py_Void();
    9732             : }
    9733             : 
    9734           0 : SWIGINTERN PyObject *_wrap_webObj_log_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9735             :   PyObject *resultobj = 0;
    9736             :   webObj *arg1 = (webObj *) 0 ;
    9737             :   char *arg2 = (char *) 0 ;
    9738           0 :   void *argp1 = 0 ;
    9739             :   int res1 = 0 ;
    9740             :   int res2 ;
    9741           0 :   char *buf2 = 0 ;
    9742           0 :   int alloc2 = 0 ;
    9743           0 :   PyObject * obj0 = 0 ;
    9744           0 :   PyObject * obj1 = 0 ;
    9745             :   
    9746           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_log_set",&obj0,&obj1)) SWIG_fail;
    9747           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9748           0 :   if (!SWIG_IsOK(res1)) {
    9749           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_log_set" "', argument " "1"" of type '" "webObj *""'"); 
    9750             :   }
    9751           0 :   arg1 = (webObj *)(argp1);
    9752           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9753           0 :   if (!SWIG_IsOK(res2)) {
    9754           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_log_set" "', argument " "2"" of type '" "char *""'");
    9755             :   }
    9756           0 :   arg2 = (char *)(buf2);
    9757             :   {
    9758           0 :     if (arg1->log) free((char*)arg1->log);
    9759           0 :     if (arg2) {
    9760           0 :       arg1->log = (char *) malloc(strlen(arg2)+1);
    9761             :       strcpy((char*)arg1->log,arg2);
    9762             :     } else {
    9763           0 :       arg1->log = 0;
    9764             :     }
    9765             :   }
    9766             :   resultobj = SWIG_Py_Void();
    9767           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9768             :   return resultobj;
    9769           0 : fail:
    9770           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9771             :   return NULL;
    9772             : }
    9773             : 
    9774             : 
    9775           0 : SWIGINTERN PyObject *_wrap_webObj_log_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9776             :   PyObject *resultobj = 0;
    9777             :   webObj *arg1 = (webObj *) 0 ;
    9778           0 :   void *argp1 = 0 ;
    9779             :   int res1 = 0 ;
    9780           0 :   PyObject * obj0 = 0 ;
    9781             :   char *result = 0 ;
    9782             :   
    9783           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_log_get",&obj0)) SWIG_fail;
    9784           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9785           0 :   if (!SWIG_IsOK(res1)) {
    9786           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_log_get" "', argument " "1"" of type '" "webObj *""'"); 
    9787             :   }
    9788           0 :   arg1 = (webObj *)(argp1);
    9789           0 :   result = (char *) ((arg1)->log);
    9790           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9791           0 :   return resultobj;
    9792           0 : fail:
    9793             :   return NULL;
    9794             : }
    9795             : 
    9796             : 
    9797           1 : SWIGINTERN PyObject *_wrap_webObj_imagepath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9798             :   PyObject *resultobj = 0;
    9799             :   webObj *arg1 = (webObj *) 0 ;
    9800             :   char *arg2 = (char *) 0 ;
    9801           1 :   void *argp1 = 0 ;
    9802             :   int res1 = 0 ;
    9803             :   int res2 ;
    9804           1 :   char *buf2 = 0 ;
    9805           1 :   int alloc2 = 0 ;
    9806           1 :   PyObject * obj0 = 0 ;
    9807           1 :   PyObject * obj1 = 0 ;
    9808             :   
    9809           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_imagepath_set",&obj0,&obj1)) SWIG_fail;
    9810           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9811           1 :   if (!SWIG_IsOK(res1)) {
    9812           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imagepath_set" "', argument " "1"" of type '" "webObj *""'"); 
    9813             :   }
    9814           1 :   arg1 = (webObj *)(argp1);
    9815           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9816           1 :   if (!SWIG_IsOK(res2)) {
    9817           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_imagepath_set" "', argument " "2"" of type '" "char *""'");
    9818             :   }
    9819           1 :   arg2 = (char *)(buf2);
    9820             :   {
    9821           1 :     if (arg1->imagepath) free((char*)arg1->imagepath);
    9822           1 :     if (arg2) {
    9823           1 :       arg1->imagepath = (char *) malloc(strlen(arg2)+1);
    9824             :       strcpy((char*)arg1->imagepath,arg2);
    9825             :     } else {
    9826           0 :       arg1->imagepath = 0;
    9827             :     }
    9828             :   }
    9829             :   resultobj = SWIG_Py_Void();
    9830           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9831             :   return resultobj;
    9832           0 : fail:
    9833           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9834             :   return NULL;
    9835             : }
    9836             : 
    9837             : 
    9838           1 : SWIGINTERN PyObject *_wrap_webObj_imagepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9839             :   PyObject *resultobj = 0;
    9840             :   webObj *arg1 = (webObj *) 0 ;
    9841           1 :   void *argp1 = 0 ;
    9842             :   int res1 = 0 ;
    9843           1 :   PyObject * obj0 = 0 ;
    9844             :   char *result = 0 ;
    9845             :   
    9846           1 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_imagepath_get",&obj0)) SWIG_fail;
    9847           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9848           1 :   if (!SWIG_IsOK(res1)) {
    9849           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imagepath_get" "', argument " "1"" of type '" "webObj *""'"); 
    9850             :   }
    9851           1 :   arg1 = (webObj *)(argp1);
    9852           1 :   result = (char *) ((arg1)->imagepath);
    9853           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9854           1 :   return resultobj;
    9855           0 : fail:
    9856             :   return NULL;
    9857             : }
    9858             : 
    9859             : 
    9860           0 : SWIGINTERN PyObject *_wrap_webObj_imageurl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9861             :   PyObject *resultobj = 0;
    9862             :   webObj *arg1 = (webObj *) 0 ;
    9863             :   char *arg2 = (char *) 0 ;
    9864           0 :   void *argp1 = 0 ;
    9865             :   int res1 = 0 ;
    9866             :   int res2 ;
    9867           0 :   char *buf2 = 0 ;
    9868           0 :   int alloc2 = 0 ;
    9869           0 :   PyObject * obj0 = 0 ;
    9870           0 :   PyObject * obj1 = 0 ;
    9871             :   
    9872           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_imageurl_set",&obj0,&obj1)) SWIG_fail;
    9873           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9874           0 :   if (!SWIG_IsOK(res1)) {
    9875           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imageurl_set" "', argument " "1"" of type '" "webObj *""'"); 
    9876             :   }
    9877           0 :   arg1 = (webObj *)(argp1);
    9878           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9879           0 :   if (!SWIG_IsOK(res2)) {
    9880           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_imageurl_set" "', argument " "2"" of type '" "char *""'");
    9881             :   }
    9882           0 :   arg2 = (char *)(buf2);
    9883             :   {
    9884           0 :     if (arg1->imageurl) free((char*)arg1->imageurl);
    9885           0 :     if (arg2) {
    9886           0 :       arg1->imageurl = (char *) malloc(strlen(arg2)+1);
    9887             :       strcpy((char*)arg1->imageurl,arg2);
    9888             :     } else {
    9889           0 :       arg1->imageurl = 0;
    9890             :     }
    9891             :   }
    9892             :   resultobj = SWIG_Py_Void();
    9893           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9894             :   return resultobj;
    9895           0 : fail:
    9896           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9897             :   return NULL;
    9898             : }
    9899             : 
    9900             : 
    9901           0 : SWIGINTERN PyObject *_wrap_webObj_imageurl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9902             :   PyObject *resultobj = 0;
    9903             :   webObj *arg1 = (webObj *) 0 ;
    9904           0 :   void *argp1 = 0 ;
    9905             :   int res1 = 0 ;
    9906           0 :   PyObject * obj0 = 0 ;
    9907             :   char *result = 0 ;
    9908             :   
    9909           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_imageurl_get",&obj0)) SWIG_fail;
    9910           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9911           0 :   if (!SWIG_IsOK(res1)) {
    9912           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imageurl_get" "', argument " "1"" of type '" "webObj *""'"); 
    9913             :   }
    9914           0 :   arg1 = (webObj *)(argp1);
    9915           0 :   result = (char *) ((arg1)->imageurl);
    9916           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9917           0 :   return resultobj;
    9918           0 : fail:
    9919             :   return NULL;
    9920             : }
    9921             : 
    9922             : 
    9923           0 : SWIGINTERN PyObject *_wrap_webObj_temppath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9924             :   PyObject *resultobj = 0;
    9925             :   webObj *arg1 = (webObj *) 0 ;
    9926             :   char *arg2 = (char *) 0 ;
    9927           0 :   void *argp1 = 0 ;
    9928             :   int res1 = 0 ;
    9929             :   int res2 ;
    9930           0 :   char *buf2 = 0 ;
    9931           0 :   int alloc2 = 0 ;
    9932           0 :   PyObject * obj0 = 0 ;
    9933           0 :   PyObject * obj1 = 0 ;
    9934             :   
    9935           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_temppath_set",&obj0,&obj1)) SWIG_fail;
    9936           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9937           0 :   if (!SWIG_IsOK(res1)) {
    9938           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_temppath_set" "', argument " "1"" of type '" "webObj *""'"); 
    9939             :   }
    9940           0 :   arg1 = (webObj *)(argp1);
    9941           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9942           0 :   if (!SWIG_IsOK(res2)) {
    9943           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_temppath_set" "', argument " "2"" of type '" "char *""'");
    9944             :   }
    9945           0 :   arg2 = (char *)(buf2);
    9946             :   {
    9947           0 :     if (arg1->temppath) free((char*)arg1->temppath);
    9948           0 :     if (arg2) {
    9949           0 :       arg1->temppath = (char *) malloc(strlen(arg2)+1);
    9950             :       strcpy((char*)arg1->temppath,arg2);
    9951             :     } else {
    9952           0 :       arg1->temppath = 0;
    9953             :     }
    9954             :   }
    9955             :   resultobj = SWIG_Py_Void();
    9956           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9957             :   return resultobj;
    9958           0 : fail:
    9959           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
    9960             :   return NULL;
    9961             : }
    9962             : 
    9963             : 
    9964           0 : SWIGINTERN PyObject *_wrap_webObj_temppath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9965             :   PyObject *resultobj = 0;
    9966             :   webObj *arg1 = (webObj *) 0 ;
    9967           0 :   void *argp1 = 0 ;
    9968             :   int res1 = 0 ;
    9969           0 :   PyObject * obj0 = 0 ;
    9970             :   char *result = 0 ;
    9971             :   
    9972           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_temppath_get",&obj0)) SWIG_fail;
    9973           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9974           0 :   if (!SWIG_IsOK(res1)) {
    9975           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_temppath_get" "', argument " "1"" of type '" "webObj *""'"); 
    9976             :   }
    9977           0 :   arg1 = (webObj *)(argp1);
    9978           0 :   result = (char *) ((arg1)->temppath);
    9979           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9980           0 :   return resultobj;
    9981           0 : fail:
    9982             :   return NULL;
    9983             : }
    9984             : 
    9985             : 
    9986           0 : SWIGINTERN PyObject *_wrap_webObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9987             :   PyObject *resultobj = 0;
    9988             :   webObj *arg1 = (webObj *) 0 ;
    9989           0 :   void *argp1 = 0 ;
    9990             :   int res1 = 0 ;
    9991           0 :   PyObject * obj0 = 0 ;
    9992             :   struct mapObj *result = 0 ;
    9993             :   
    9994           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_map_get",&obj0)) SWIG_fail;
    9995           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
    9996           0 :   if (!SWIG_IsOK(res1)) {
    9997           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_map_get" "', argument " "1"" of type '" "webObj *""'"); 
    9998             :   }
    9999           0 :   arg1 = (webObj *)(argp1);
   10000           0 :   result = (struct mapObj *) ((arg1)->map);
   10001           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 |  0 );
   10002           0 :   return resultobj;
   10003           0 : fail:
   10004             :   return NULL;
   10005             : }
   10006             : 
   10007             : 
   10008           0 : SWIGINTERN PyObject *_wrap_webObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10009             :   PyObject *resultobj = 0;
   10010             :   webObj *arg1 = (webObj *) 0 ;
   10011             :   char *arg2 = (char *) 0 ;
   10012           0 :   void *argp1 = 0 ;
   10013             :   int res1 = 0 ;
   10014             :   int res2 ;
   10015           0 :   char *buf2 = 0 ;
   10016           0 :   int alloc2 = 0 ;
   10017           0 :   PyObject * obj0 = 0 ;
   10018           0 :   PyObject * obj1 = 0 ;
   10019             :   
   10020           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_template_set",&obj0,&obj1)) SWIG_fail;
   10021           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10022           0 :   if (!SWIG_IsOK(res1)) {
   10023           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_template_set" "', argument " "1"" of type '" "webObj *""'"); 
   10024             :   }
   10025           0 :   arg1 = (webObj *)(argp1);
   10026           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10027           0 :   if (!SWIG_IsOK(res2)) {
   10028           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_template_set" "', argument " "2"" of type '" "char *""'");
   10029             :   }
   10030           0 :   arg2 = (char *)(buf2);
   10031             :   {
   10032           0 :     if (arg1->template) free((char*)arg1->template);
   10033           0 :     if (arg2) {
   10034           0 :       arg1->template = (char *) malloc(strlen(arg2)+1);
   10035             :       strcpy((char*)arg1->template,arg2);
   10036             :     } else {
   10037           0 :       arg1->template = 0;
   10038             :     }
   10039             :   }
   10040             :   resultobj = SWIG_Py_Void();
   10041           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10042             :   return resultobj;
   10043           0 : fail:
   10044           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10045             :   return NULL;
   10046             : }
   10047             : 
   10048             : 
   10049           0 : SWIGINTERN PyObject *_wrap_webObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10050             :   PyObject *resultobj = 0;
   10051             :   webObj *arg1 = (webObj *) 0 ;
   10052           0 :   void *argp1 = 0 ;
   10053             :   int res1 = 0 ;
   10054           0 :   PyObject * obj0 = 0 ;
   10055             :   char *result = 0 ;
   10056             :   
   10057           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_template_get",&obj0)) SWIG_fail;
   10058           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10059           0 :   if (!SWIG_IsOK(res1)) {
   10060           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_template_get" "', argument " "1"" of type '" "webObj *""'"); 
   10061             :   }
   10062           0 :   arg1 = (webObj *)(argp1);
   10063           0 :   result = (char *) ((arg1)->template);
   10064           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10065           0 :   return resultobj;
   10066           0 : fail:
   10067             :   return NULL;
   10068             : }
   10069             : 
   10070             : 
   10071           0 : SWIGINTERN PyObject *_wrap_webObj_header_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10072             :   PyObject *resultobj = 0;
   10073             :   webObj *arg1 = (webObj *) 0 ;
   10074             :   char *arg2 = (char *) 0 ;
   10075           0 :   void *argp1 = 0 ;
   10076             :   int res1 = 0 ;
   10077             :   int res2 ;
   10078           0 :   char *buf2 = 0 ;
   10079           0 :   int alloc2 = 0 ;
   10080           0 :   PyObject * obj0 = 0 ;
   10081           0 :   PyObject * obj1 = 0 ;
   10082             :   
   10083           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_header_set",&obj0,&obj1)) SWIG_fail;
   10084           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10085           0 :   if (!SWIG_IsOK(res1)) {
   10086           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_header_set" "', argument " "1"" of type '" "webObj *""'"); 
   10087             :   }
   10088           0 :   arg1 = (webObj *)(argp1);
   10089           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10090           0 :   if (!SWIG_IsOK(res2)) {
   10091           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_header_set" "', argument " "2"" of type '" "char *""'");
   10092             :   }
   10093           0 :   arg2 = (char *)(buf2);
   10094             :   {
   10095           0 :     if (arg1->header) free((char*)arg1->header);
   10096           0 :     if (arg2) {
   10097           0 :       arg1->header = (char *) malloc(strlen(arg2)+1);
   10098             :       strcpy((char*)arg1->header,arg2);
   10099             :     } else {
   10100           0 :       arg1->header = 0;
   10101             :     }
   10102             :   }
   10103             :   resultobj = SWIG_Py_Void();
   10104           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10105             :   return resultobj;
   10106           0 : fail:
   10107           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10108             :   return NULL;
   10109             : }
   10110             : 
   10111             : 
   10112           0 : SWIGINTERN PyObject *_wrap_webObj_header_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10113             :   PyObject *resultobj = 0;
   10114             :   webObj *arg1 = (webObj *) 0 ;
   10115           0 :   void *argp1 = 0 ;
   10116             :   int res1 = 0 ;
   10117           0 :   PyObject * obj0 = 0 ;
   10118             :   char *result = 0 ;
   10119             :   
   10120           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_header_get",&obj0)) SWIG_fail;
   10121           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10122           0 :   if (!SWIG_IsOK(res1)) {
   10123           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_header_get" "', argument " "1"" of type '" "webObj *""'"); 
   10124             :   }
   10125           0 :   arg1 = (webObj *)(argp1);
   10126           0 :   result = (char *) ((arg1)->header);
   10127           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10128           0 :   return resultobj;
   10129           0 : fail:
   10130             :   return NULL;
   10131             : }
   10132             : 
   10133             : 
   10134           0 : SWIGINTERN PyObject *_wrap_webObj_footer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10135             :   PyObject *resultobj = 0;
   10136             :   webObj *arg1 = (webObj *) 0 ;
   10137             :   char *arg2 = (char *) 0 ;
   10138           0 :   void *argp1 = 0 ;
   10139             :   int res1 = 0 ;
   10140             :   int res2 ;
   10141           0 :   char *buf2 = 0 ;
   10142           0 :   int alloc2 = 0 ;
   10143           0 :   PyObject * obj0 = 0 ;
   10144           0 :   PyObject * obj1 = 0 ;
   10145             :   
   10146           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_footer_set",&obj0,&obj1)) SWIG_fail;
   10147           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10148           0 :   if (!SWIG_IsOK(res1)) {
   10149           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_footer_set" "', argument " "1"" of type '" "webObj *""'"); 
   10150             :   }
   10151           0 :   arg1 = (webObj *)(argp1);
   10152           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10153           0 :   if (!SWIG_IsOK(res2)) {
   10154           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_footer_set" "', argument " "2"" of type '" "char *""'");
   10155             :   }
   10156           0 :   arg2 = (char *)(buf2);
   10157             :   {
   10158           0 :     if (arg1->footer) free((char*)arg1->footer);
   10159           0 :     if (arg2) {
   10160           0 :       arg1->footer = (char *) malloc(strlen(arg2)+1);
   10161             :       strcpy((char*)arg1->footer,arg2);
   10162             :     } else {
   10163           0 :       arg1->footer = 0;
   10164             :     }
   10165             :   }
   10166             :   resultobj = SWIG_Py_Void();
   10167           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10168             :   return resultobj;
   10169           0 : fail:
   10170           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10171             :   return NULL;
   10172             : }
   10173             : 
   10174             : 
   10175           0 : SWIGINTERN PyObject *_wrap_webObj_footer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10176             :   PyObject *resultobj = 0;
   10177             :   webObj *arg1 = (webObj *) 0 ;
   10178           0 :   void *argp1 = 0 ;
   10179             :   int res1 = 0 ;
   10180           0 :   PyObject * obj0 = 0 ;
   10181             :   char *result = 0 ;
   10182             :   
   10183           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_footer_get",&obj0)) SWIG_fail;
   10184           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10185           0 :   if (!SWIG_IsOK(res1)) {
   10186           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_footer_get" "', argument " "1"" of type '" "webObj *""'"); 
   10187             :   }
   10188           0 :   arg1 = (webObj *)(argp1);
   10189           0 :   result = (char *) ((arg1)->footer);
   10190           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10191           0 :   return resultobj;
   10192           0 : fail:
   10193             :   return NULL;
   10194             : }
   10195             : 
   10196             : 
   10197           0 : SWIGINTERN PyObject *_wrap_webObj_empty_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10198             :   PyObject *resultobj = 0;
   10199             :   webObj *arg1 = (webObj *) 0 ;
   10200             :   char *arg2 = (char *) 0 ;
   10201           0 :   void *argp1 = 0 ;
   10202             :   int res1 = 0 ;
   10203             :   int res2 ;
   10204           0 :   char *buf2 = 0 ;
   10205           0 :   int alloc2 = 0 ;
   10206           0 :   PyObject * obj0 = 0 ;
   10207           0 :   PyObject * obj1 = 0 ;
   10208             :   
   10209           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_empty_set",&obj0,&obj1)) SWIG_fail;
   10210           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10211           0 :   if (!SWIG_IsOK(res1)) {
   10212           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_empty_set" "', argument " "1"" of type '" "webObj *""'"); 
   10213             :   }
   10214           0 :   arg1 = (webObj *)(argp1);
   10215           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10216           0 :   if (!SWIG_IsOK(res2)) {
   10217           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_empty_set" "', argument " "2"" of type '" "char *""'");
   10218             :   }
   10219           0 :   arg2 = (char *)(buf2);
   10220             :   {
   10221           0 :     if (arg1->empty) free((char*)arg1->empty);
   10222           0 :     if (arg2) {
   10223           0 :       arg1->empty = (char *) malloc(strlen(arg2)+1);
   10224             :       strcpy((char*)arg1->empty,arg2);
   10225             :     } else {
   10226           0 :       arg1->empty = 0;
   10227             :     }
   10228             :   }
   10229             :   resultobj = SWIG_Py_Void();
   10230           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10231             :   return resultobj;
   10232           0 : fail:
   10233           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10234             :   return NULL;
   10235             : }
   10236             : 
   10237             : 
   10238           0 : SWIGINTERN PyObject *_wrap_webObj_empty_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10239             :   PyObject *resultobj = 0;
   10240             :   webObj *arg1 = (webObj *) 0 ;
   10241           0 :   void *argp1 = 0 ;
   10242             :   int res1 = 0 ;
   10243           0 :   PyObject * obj0 = 0 ;
   10244             :   char *result = 0 ;
   10245             :   
   10246           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_empty_get",&obj0)) SWIG_fail;
   10247           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10248           0 :   if (!SWIG_IsOK(res1)) {
   10249           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_empty_get" "', argument " "1"" of type '" "webObj *""'"); 
   10250             :   }
   10251           0 :   arg1 = (webObj *)(argp1);
   10252           0 :   result = (char *) ((arg1)->empty);
   10253           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10254           0 :   return resultobj;
   10255           0 : fail:
   10256             :   return NULL;
   10257             : }
   10258             : 
   10259             : 
   10260           0 : SWIGINTERN PyObject *_wrap_webObj_error_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10261             :   PyObject *resultobj = 0;
   10262             :   webObj *arg1 = (webObj *) 0 ;
   10263             :   char *arg2 = (char *) 0 ;
   10264           0 :   void *argp1 = 0 ;
   10265             :   int res1 = 0 ;
   10266             :   int res2 ;
   10267           0 :   char *buf2 = 0 ;
   10268           0 :   int alloc2 = 0 ;
   10269           0 :   PyObject * obj0 = 0 ;
   10270           0 :   PyObject * obj1 = 0 ;
   10271             :   
   10272           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_error_set",&obj0,&obj1)) SWIG_fail;
   10273           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10274           0 :   if (!SWIG_IsOK(res1)) {
   10275           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_error_set" "', argument " "1"" of type '" "webObj *""'"); 
   10276             :   }
   10277           0 :   arg1 = (webObj *)(argp1);
   10278           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10279           0 :   if (!SWIG_IsOK(res2)) {
   10280           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_error_set" "', argument " "2"" of type '" "char *""'");
   10281             :   }
   10282           0 :   arg2 = (char *)(buf2);
   10283             :   {
   10284           0 :     if (arg1->error) free((char*)arg1->error);
   10285           0 :     if (arg2) {
   10286           0 :       arg1->error = (char *) malloc(strlen(arg2)+1);
   10287             :       strcpy((char*)arg1->error,arg2);
   10288             :     } else {
   10289           0 :       arg1->error = 0;
   10290             :     }
   10291             :   }
   10292             :   resultobj = SWIG_Py_Void();
   10293           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10294             :   return resultobj;
   10295           0 : fail:
   10296           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10297             :   return NULL;
   10298             : }
   10299             : 
   10300             : 
   10301           0 : SWIGINTERN PyObject *_wrap_webObj_error_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10302             :   PyObject *resultobj = 0;
   10303             :   webObj *arg1 = (webObj *) 0 ;
   10304           0 :   void *argp1 = 0 ;
   10305             :   int res1 = 0 ;
   10306           0 :   PyObject * obj0 = 0 ;
   10307             :   char *result = 0 ;
   10308             :   
   10309           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_error_get",&obj0)) SWIG_fail;
   10310           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10311           0 :   if (!SWIG_IsOK(res1)) {
   10312           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_error_get" "', argument " "1"" of type '" "webObj *""'"); 
   10313             :   }
   10314           0 :   arg1 = (webObj *)(argp1);
   10315           0 :   result = (char *) ((arg1)->error);
   10316           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10317           0 :   return resultobj;
   10318           0 : fail:
   10319             :   return NULL;
   10320             : }
   10321             : 
   10322             : 
   10323           0 : SWIGINTERN PyObject *_wrap_webObj_extent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10324             :   PyObject *resultobj = 0;
   10325             :   webObj *arg1 = (webObj *) 0 ;
   10326             :   rectObj *arg2 = (rectObj *) 0 ;
   10327           0 :   void *argp1 = 0 ;
   10328             :   int res1 = 0 ;
   10329           0 :   void *argp2 = 0 ;
   10330             :   int res2 = 0 ;
   10331           0 :   PyObject * obj0 = 0 ;
   10332           0 :   PyObject * obj1 = 0 ;
   10333             :   
   10334           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_extent_set",&obj0,&obj1)) SWIG_fail;
   10335           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10336           0 :   if (!SWIG_IsOK(res1)) {
   10337           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_extent_set" "', argument " "1"" of type '" "webObj *""'"); 
   10338             :   }
   10339           0 :   arg1 = (webObj *)(argp1);
   10340           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 |  0 );
   10341           0 :   if (!SWIG_IsOK(res2)) {
   10342           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_extent_set" "', argument " "2"" of type '" "rectObj *""'"); 
   10343             :   }
   10344           0 :   arg2 = (rectObj *)(argp2);
   10345           0 :   if (arg1) (arg1)->extent = *arg2;
   10346             :   resultobj = SWIG_Py_Void();
   10347           0 :   return resultobj;
   10348           0 : fail:
   10349             :   return NULL;
   10350             : }
   10351             : 
   10352             : 
   10353           0 : SWIGINTERN PyObject *_wrap_webObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10354             :   PyObject *resultobj = 0;
   10355             :   webObj *arg1 = (webObj *) 0 ;
   10356           0 :   void *argp1 = 0 ;
   10357             :   int res1 = 0 ;
   10358           0 :   PyObject * obj0 = 0 ;
   10359             :   rectObj *result = 0 ;
   10360             :   
   10361           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_extent_get",&obj0)) SWIG_fail;
   10362           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10363           0 :   if (!SWIG_IsOK(res1)) {
   10364           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_extent_get" "', argument " "1"" of type '" "webObj *""'"); 
   10365             :   }
   10366           0 :   arg1 = (webObj *)(argp1);
   10367           0 :   result = (rectObj *)& ((arg1)->extent);
   10368           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   10369           0 :   return resultobj;
   10370           0 : fail:
   10371             :   return NULL;
   10372             : }
   10373             : 
   10374             : 
   10375           0 : SWIGINTERN PyObject *_wrap_webObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10376             :   PyObject *resultobj = 0;
   10377             :   webObj *arg1 = (webObj *) 0 ;
   10378             :   double arg2 ;
   10379           0 :   void *argp1 = 0 ;
   10380             :   int res1 = 0 ;
   10381             :   double val2 ;
   10382             :   int ecode2 = 0 ;
   10383           0 :   PyObject * obj0 = 0 ;
   10384           0 :   PyObject * obj1 = 0 ;
   10385             :   
   10386           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
   10387           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10388           0 :   if (!SWIG_IsOK(res1)) {
   10389           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_minscaledenom_set" "', argument " "1"" of type '" "webObj *""'"); 
   10390             :   }
   10391           0 :   arg1 = (webObj *)(argp1);
   10392           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   10393           0 :   if (!SWIG_IsOK(ecode2)) {
   10394           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "webObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
   10395             :   } 
   10396           0 :   arg2 = (double)(val2);
   10397           0 :   if (arg1) (arg1)->minscaledenom = arg2;
   10398             :   resultobj = SWIG_Py_Void();
   10399           0 :   return resultobj;
   10400           0 : fail:
   10401             :   return NULL;
   10402             : }
   10403             : 
   10404             : 
   10405           0 : SWIGINTERN PyObject *_wrap_webObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10406             :   PyObject *resultobj = 0;
   10407             :   webObj *arg1 = (webObj *) 0 ;
   10408           0 :   void *argp1 = 0 ;
   10409             :   int res1 = 0 ;
   10410           0 :   PyObject * obj0 = 0 ;
   10411             :   double result;
   10412             :   
   10413           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_minscaledenom_get",&obj0)) SWIG_fail;
   10414           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10415           0 :   if (!SWIG_IsOK(res1)) {
   10416           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_minscaledenom_get" "', argument " "1"" of type '" "webObj *""'"); 
   10417             :   }
   10418           0 :   arg1 = (webObj *)(argp1);
   10419           0 :   result = (double) ((arg1)->minscaledenom);
   10420           0 :   resultobj = SWIG_From_double((double)(result));
   10421           0 :   return resultobj;
   10422           0 : fail:
   10423             :   return NULL;
   10424             : }
   10425             : 
   10426             : 
   10427           0 : SWIGINTERN PyObject *_wrap_webObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10428             :   PyObject *resultobj = 0;
   10429             :   webObj *arg1 = (webObj *) 0 ;
   10430             :   double arg2 ;
   10431           0 :   void *argp1 = 0 ;
   10432             :   int res1 = 0 ;
   10433             :   double val2 ;
   10434             :   int ecode2 = 0 ;
   10435           0 :   PyObject * obj0 = 0 ;
   10436           0 :   PyObject * obj1 = 0 ;
   10437             :   
   10438           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
   10439           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10440           0 :   if (!SWIG_IsOK(res1)) {
   10441           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxscaledenom_set" "', argument " "1"" of type '" "webObj *""'"); 
   10442             :   }
   10443           0 :   arg1 = (webObj *)(argp1);
   10444           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   10445           0 :   if (!SWIG_IsOK(ecode2)) {
   10446           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "webObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
   10447             :   } 
   10448           0 :   arg2 = (double)(val2);
   10449           0 :   if (arg1) (arg1)->maxscaledenom = arg2;
   10450             :   resultobj = SWIG_Py_Void();
   10451           0 :   return resultobj;
   10452           0 : fail:
   10453             :   return NULL;
   10454             : }
   10455             : 
   10456             : 
   10457           0 : SWIGINTERN PyObject *_wrap_webObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10458             :   PyObject *resultobj = 0;
   10459             :   webObj *arg1 = (webObj *) 0 ;
   10460           0 :   void *argp1 = 0 ;
   10461             :   int res1 = 0 ;
   10462           0 :   PyObject * obj0 = 0 ;
   10463             :   double result;
   10464             :   
   10465           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_maxscaledenom_get",&obj0)) SWIG_fail;
   10466           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10467           0 :   if (!SWIG_IsOK(res1)) {
   10468           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxscaledenom_get" "', argument " "1"" of type '" "webObj *""'"); 
   10469             :   }
   10470           0 :   arg1 = (webObj *)(argp1);
   10471           0 :   result = (double) ((arg1)->maxscaledenom);
   10472           0 :   resultobj = SWIG_From_double((double)(result));
   10473           0 :   return resultobj;
   10474           0 : fail:
   10475             :   return NULL;
   10476             : }
   10477             : 
   10478             : 
   10479           0 : SWIGINTERN PyObject *_wrap_webObj_mintemplate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10480             :   PyObject *resultobj = 0;
   10481             :   webObj *arg1 = (webObj *) 0 ;
   10482             :   char *arg2 = (char *) 0 ;
   10483           0 :   void *argp1 = 0 ;
   10484             :   int res1 = 0 ;
   10485             :   int res2 ;
   10486           0 :   char *buf2 = 0 ;
   10487           0 :   int alloc2 = 0 ;
   10488           0 :   PyObject * obj0 = 0 ;
   10489           0 :   PyObject * obj1 = 0 ;
   10490             :   
   10491           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_mintemplate_set",&obj0,&obj1)) SWIG_fail;
   10492           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10493           0 :   if (!SWIG_IsOK(res1)) {
   10494           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_mintemplate_set" "', argument " "1"" of type '" "webObj *""'"); 
   10495             :   }
   10496           0 :   arg1 = (webObj *)(argp1);
   10497           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10498           0 :   if (!SWIG_IsOK(res2)) {
   10499           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_mintemplate_set" "', argument " "2"" of type '" "char *""'");
   10500             :   }
   10501           0 :   arg2 = (char *)(buf2);
   10502             :   {
   10503           0 :     if (arg1->mintemplate) free((char*)arg1->mintemplate);
   10504           0 :     if (arg2) {
   10505           0 :       arg1->mintemplate = (char *) malloc(strlen(arg2)+1);
   10506             :       strcpy((char*)arg1->mintemplate,arg2);
   10507             :     } else {
   10508           0 :       arg1->mintemplate = 0;
   10509             :     }
   10510             :   }
   10511             :   resultobj = SWIG_Py_Void();
   10512           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10513             :   return resultobj;
   10514           0 : fail:
   10515           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10516             :   return NULL;
   10517             : }
   10518             : 
   10519             : 
   10520           0 : SWIGINTERN PyObject *_wrap_webObj_mintemplate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10521             :   PyObject *resultobj = 0;
   10522             :   webObj *arg1 = (webObj *) 0 ;
   10523           0 :   void *argp1 = 0 ;
   10524             :   int res1 = 0 ;
   10525           0 :   PyObject * obj0 = 0 ;
   10526             :   char *result = 0 ;
   10527             :   
   10528           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_mintemplate_get",&obj0)) SWIG_fail;
   10529           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10530           0 :   if (!SWIG_IsOK(res1)) {
   10531           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_mintemplate_get" "', argument " "1"" of type '" "webObj *""'"); 
   10532             :   }
   10533           0 :   arg1 = (webObj *)(argp1);
   10534           0 :   result = (char *) ((arg1)->mintemplate);
   10535           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10536           0 :   return resultobj;
   10537           0 : fail:
   10538             :   return NULL;
   10539             : }
   10540             : 
   10541             : 
   10542           0 : SWIGINTERN PyObject *_wrap_webObj_maxtemplate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10543             :   PyObject *resultobj = 0;
   10544             :   webObj *arg1 = (webObj *) 0 ;
   10545             :   char *arg2 = (char *) 0 ;
   10546           0 :   void *argp1 = 0 ;
   10547             :   int res1 = 0 ;
   10548             :   int res2 ;
   10549           0 :   char *buf2 = 0 ;
   10550           0 :   int alloc2 = 0 ;
   10551           0 :   PyObject * obj0 = 0 ;
   10552           0 :   PyObject * obj1 = 0 ;
   10553             :   
   10554           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_maxtemplate_set",&obj0,&obj1)) SWIG_fail;
   10555           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10556           0 :   if (!SWIG_IsOK(res1)) {
   10557           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxtemplate_set" "', argument " "1"" of type '" "webObj *""'"); 
   10558             :   }
   10559           0 :   arg1 = (webObj *)(argp1);
   10560           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10561           0 :   if (!SWIG_IsOK(res2)) {
   10562           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_maxtemplate_set" "', argument " "2"" of type '" "char *""'");
   10563             :   }
   10564           0 :   arg2 = (char *)(buf2);
   10565             :   {
   10566           0 :     if (arg1->maxtemplate) free((char*)arg1->maxtemplate);
   10567           0 :     if (arg2) {
   10568           0 :       arg1->maxtemplate = (char *) malloc(strlen(arg2)+1);
   10569             :       strcpy((char*)arg1->maxtemplate,arg2);
   10570             :     } else {
   10571           0 :       arg1->maxtemplate = 0;
   10572             :     }
   10573             :   }
   10574             :   resultobj = SWIG_Py_Void();
   10575           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10576             :   return resultobj;
   10577           0 : fail:
   10578           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10579             :   return NULL;
   10580             : }
   10581             : 
   10582             : 
   10583           0 : SWIGINTERN PyObject *_wrap_webObj_maxtemplate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10584             :   PyObject *resultobj = 0;
   10585             :   webObj *arg1 = (webObj *) 0 ;
   10586           0 :   void *argp1 = 0 ;
   10587             :   int res1 = 0 ;
   10588           0 :   PyObject * obj0 = 0 ;
   10589             :   char *result = 0 ;
   10590             :   
   10591           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_maxtemplate_get",&obj0)) SWIG_fail;
   10592           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10593           0 :   if (!SWIG_IsOK(res1)) {
   10594           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxtemplate_get" "', argument " "1"" of type '" "webObj *""'"); 
   10595             :   }
   10596           0 :   arg1 = (webObj *)(argp1);
   10597           0 :   result = (char *) ((arg1)->maxtemplate);
   10598           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10599           0 :   return resultobj;
   10600           0 : fail:
   10601             :   return NULL;
   10602             : }
   10603             : 
   10604             : 
   10605           0 : SWIGINTERN PyObject *_wrap_webObj_queryformat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10606             :   PyObject *resultobj = 0;
   10607             :   webObj *arg1 = (webObj *) 0 ;
   10608             :   char *arg2 = (char *) 0 ;
   10609           0 :   void *argp1 = 0 ;
   10610             :   int res1 = 0 ;
   10611             :   int res2 ;
   10612           0 :   char *buf2 = 0 ;
   10613           0 :   int alloc2 = 0 ;
   10614           0 :   PyObject * obj0 = 0 ;
   10615           0 :   PyObject * obj1 = 0 ;
   10616             :   
   10617           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_queryformat_set",&obj0,&obj1)) SWIG_fail;
   10618           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10619           0 :   if (!SWIG_IsOK(res1)) {
   10620           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_queryformat_set" "', argument " "1"" of type '" "webObj *""'"); 
   10621             :   }
   10622           0 :   arg1 = (webObj *)(argp1);
   10623           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10624           0 :   if (!SWIG_IsOK(res2)) {
   10625           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_queryformat_set" "', argument " "2"" of type '" "char *""'");
   10626             :   }
   10627           0 :   arg2 = (char *)(buf2);
   10628             :   {
   10629           0 :     if (arg1->queryformat) free((char*)arg1->queryformat);
   10630           0 :     if (arg2) {
   10631           0 :       arg1->queryformat = (char *) malloc(strlen(arg2)+1);
   10632             :       strcpy((char*)arg1->queryformat,arg2);
   10633             :     } else {
   10634           0 :       arg1->queryformat = 0;
   10635             :     }
   10636             :   }
   10637             :   resultobj = SWIG_Py_Void();
   10638           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10639             :   return resultobj;
   10640           0 : fail:
   10641           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10642             :   return NULL;
   10643             : }
   10644             : 
   10645             : 
   10646           0 : SWIGINTERN PyObject *_wrap_webObj_queryformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10647             :   PyObject *resultobj = 0;
   10648             :   webObj *arg1 = (webObj *) 0 ;
   10649           0 :   void *argp1 = 0 ;
   10650             :   int res1 = 0 ;
   10651           0 :   PyObject * obj0 = 0 ;
   10652             :   char *result = 0 ;
   10653             :   
   10654           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_queryformat_get",&obj0)) SWIG_fail;
   10655           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10656           0 :   if (!SWIG_IsOK(res1)) {
   10657           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_queryformat_get" "', argument " "1"" of type '" "webObj *""'"); 
   10658             :   }
   10659           0 :   arg1 = (webObj *)(argp1);
   10660           0 :   result = (char *) ((arg1)->queryformat);
   10661           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10662           0 :   return resultobj;
   10663           0 : fail:
   10664             :   return NULL;
   10665             : }
   10666             : 
   10667             : 
   10668           0 : SWIGINTERN PyObject *_wrap_webObj_legendformat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10669             :   PyObject *resultobj = 0;
   10670             :   webObj *arg1 = (webObj *) 0 ;
   10671             :   char *arg2 = (char *) 0 ;
   10672           0 :   void *argp1 = 0 ;
   10673             :   int res1 = 0 ;
   10674             :   int res2 ;
   10675           0 :   char *buf2 = 0 ;
   10676           0 :   int alloc2 = 0 ;
   10677           0 :   PyObject * obj0 = 0 ;
   10678           0 :   PyObject * obj1 = 0 ;
   10679             :   
   10680           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_legendformat_set",&obj0,&obj1)) SWIG_fail;
   10681           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10682           0 :   if (!SWIG_IsOK(res1)) {
   10683           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_legendformat_set" "', argument " "1"" of type '" "webObj *""'"); 
   10684             :   }
   10685           0 :   arg1 = (webObj *)(argp1);
   10686           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10687           0 :   if (!SWIG_IsOK(res2)) {
   10688           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_legendformat_set" "', argument " "2"" of type '" "char *""'");
   10689             :   }
   10690           0 :   arg2 = (char *)(buf2);
   10691             :   {
   10692           0 :     if (arg1->legendformat) free((char*)arg1->legendformat);
   10693           0 :     if (arg2) {
   10694           0 :       arg1->legendformat = (char *) malloc(strlen(arg2)+1);
   10695             :       strcpy((char*)arg1->legendformat,arg2);
   10696             :     } else {
   10697           0 :       arg1->legendformat = 0;
   10698             :     }
   10699             :   }
   10700             :   resultobj = SWIG_Py_Void();
   10701           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10702             :   return resultobj;
   10703           0 : fail:
   10704           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10705             :   return NULL;
   10706             : }
   10707             : 
   10708             : 
   10709           0 : SWIGINTERN PyObject *_wrap_webObj_legendformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10710             :   PyObject *resultobj = 0;
   10711             :   webObj *arg1 = (webObj *) 0 ;
   10712           0 :   void *argp1 = 0 ;
   10713             :   int res1 = 0 ;
   10714           0 :   PyObject * obj0 = 0 ;
   10715             :   char *result = 0 ;
   10716             :   
   10717           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_legendformat_get",&obj0)) SWIG_fail;
   10718           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10719           0 :   if (!SWIG_IsOK(res1)) {
   10720           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_legendformat_get" "', argument " "1"" of type '" "webObj *""'"); 
   10721             :   }
   10722           0 :   arg1 = (webObj *)(argp1);
   10723           0 :   result = (char *) ((arg1)->legendformat);
   10724           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10725           0 :   return resultobj;
   10726           0 : fail:
   10727             :   return NULL;
   10728             : }
   10729             : 
   10730             : 
   10731           0 : SWIGINTERN PyObject *_wrap_webObj_browseformat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10732             :   PyObject *resultobj = 0;
   10733             :   webObj *arg1 = (webObj *) 0 ;
   10734             :   char *arg2 = (char *) 0 ;
   10735           0 :   void *argp1 = 0 ;
   10736             :   int res1 = 0 ;
   10737             :   int res2 ;
   10738           0 :   char *buf2 = 0 ;
   10739           0 :   int alloc2 = 0 ;
   10740           0 :   PyObject * obj0 = 0 ;
   10741           0 :   PyObject * obj1 = 0 ;
   10742             :   
   10743           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_browseformat_set",&obj0,&obj1)) SWIG_fail;
   10744           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10745           0 :   if (!SWIG_IsOK(res1)) {
   10746           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_browseformat_set" "', argument " "1"" of type '" "webObj *""'"); 
   10747             :   }
   10748           0 :   arg1 = (webObj *)(argp1);
   10749           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10750           0 :   if (!SWIG_IsOK(res2)) {
   10751           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_browseformat_set" "', argument " "2"" of type '" "char *""'");
   10752             :   }
   10753           0 :   arg2 = (char *)(buf2);
   10754             :   {
   10755           0 :     if (arg1->browseformat) free((char*)arg1->browseformat);
   10756           0 :     if (arg2) {
   10757           0 :       arg1->browseformat = (char *) malloc(strlen(arg2)+1);
   10758             :       strcpy((char*)arg1->browseformat,arg2);
   10759             :     } else {
   10760           0 :       arg1->browseformat = 0;
   10761             :     }
   10762             :   }
   10763             :   resultobj = SWIG_Py_Void();
   10764           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10765             :   return resultobj;
   10766           0 : fail:
   10767           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10768             :   return NULL;
   10769             : }
   10770             : 
   10771             : 
   10772           0 : SWIGINTERN PyObject *_wrap_webObj_browseformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10773             :   PyObject *resultobj = 0;
   10774             :   webObj *arg1 = (webObj *) 0 ;
   10775           0 :   void *argp1 = 0 ;
   10776             :   int res1 = 0 ;
   10777           0 :   PyObject * obj0 = 0 ;
   10778             :   char *result = 0 ;
   10779             :   
   10780           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_browseformat_get",&obj0)) SWIG_fail;
   10781           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10782           0 :   if (!SWIG_IsOK(res1)) {
   10783           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_browseformat_get" "', argument " "1"" of type '" "webObj *""'"); 
   10784             :   }
   10785           0 :   arg1 = (webObj *)(argp1);
   10786           0 :   result = (char *) ((arg1)->browseformat);
   10787           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10788           0 :   return resultobj;
   10789           0 : fail:
   10790             :   return NULL;
   10791             : }
   10792             : 
   10793             : 
   10794           1 : SWIGINTERN PyObject *_wrap_webObj_metadata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10795             :   PyObject *resultobj = 0;
   10796             :   webObj *arg1 = (webObj *) 0 ;
   10797           1 :   void *argp1 = 0 ;
   10798             :   int res1 = 0 ;
   10799           1 :   PyObject * obj0 = 0 ;
   10800             :   hashTableObj *result = 0 ;
   10801             :   
   10802           1 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_metadata_get",&obj0)) SWIG_fail;
   10803           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10804           1 :   if (!SWIG_IsOK(res1)) {
   10805           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_metadata_get" "', argument " "1"" of type '" "webObj *""'"); 
   10806             :   }
   10807           1 :   arg1 = (webObj *)(argp1);
   10808           1 :   result = (hashTableObj *)& ((arg1)->metadata);
   10809           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   10810           1 :   return resultobj;
   10811           0 : fail:
   10812             :   return NULL;
   10813             : }
   10814             : 
   10815             : 
   10816           0 : SWIGINTERN PyObject *_wrap_webObj_validation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10817             :   PyObject *resultobj = 0;
   10818             :   webObj *arg1 = (webObj *) 0 ;
   10819           0 :   void *argp1 = 0 ;
   10820             :   int res1 = 0 ;
   10821           0 :   PyObject * obj0 = 0 ;
   10822             :   hashTableObj *result = 0 ;
   10823             :   
   10824           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_validation_get",&obj0)) SWIG_fail;
   10825           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10826           0 :   if (!SWIG_IsOK(res1)) {
   10827           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_validation_get" "', argument " "1"" of type '" "webObj *""'"); 
   10828             :   }
   10829           0 :   arg1 = (webObj *)(argp1);
   10830           0 :   result = (hashTableObj *)& ((arg1)->validation);
   10831           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   10832           0 :   return resultobj;
   10833           0 : fail:
   10834             :   return NULL;
   10835             : }
   10836             : 
   10837             : 
   10838           0 : SWIGINTERN PyObject *_wrap_new_webObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10839             :   PyObject *resultobj = 0;
   10840             :   webObj *result = 0 ;
   10841             :   
   10842           0 :   if (!PyArg_ParseTuple(args,(char *)":new_webObj")) SWIG_fail;
   10843             :   {
   10844             :     result = (webObj *)new_webObj(); {
   10845           0 :       errorObj *ms_error = msGetErrorObj();
   10846             :       
   10847           0 :       switch(ms_error->code) {
   10848             :       case MS_NOERR:
   10849             :         break;
   10850           0 :       case MS_NOTFOUND:
   10851           0 :         msResetErrorList();
   10852           0 :         break;
   10853             :       case -1:
   10854             :         break;
   10855           0 :       case MS_IOERR:
   10856           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   10857           0 :           _raise_ms_exception();
   10858           0 :           msResetErrorList();
   10859           0 :           return NULL;
   10860             :         }
   10861             :       default:
   10862           0 :         _raise_ms_exception();
   10863           0 :         msResetErrorList();
   10864           0 :         return NULL;
   10865             :       }
   10866             :       
   10867             :     }
   10868             :   }
   10869           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_webObj, SWIG_POINTER_NEW |  0 );
   10870           0 :   return resultobj;
   10871           0 : fail:
   10872             :   return NULL;
   10873             : }
   10874             : 
   10875             : 
   10876           0 : SWIGINTERN PyObject *_wrap_delete_webObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10877             :   PyObject *resultobj = 0;
   10878             :   webObj *arg1 = (webObj *) 0 ;
   10879           0 :   void *argp1 = 0 ;
   10880             :   int res1 = 0 ;
   10881           0 :   PyObject * obj0 = 0 ;
   10882             :   
   10883           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_webObj",&obj0)) SWIG_fail;
   10884           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, SWIG_POINTER_DISOWN |  0 );
   10885           0 :   if (!SWIG_IsOK(res1)) {
   10886           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_webObj" "', argument " "1"" of type '" "webObj *""'"); 
   10887             :   }
   10888           0 :   arg1 = (webObj *)(argp1);
   10889             :   {
   10890             :     delete_webObj(arg1); {
   10891           0 :       errorObj *ms_error = msGetErrorObj();
   10892             :       
   10893           0 :       switch(ms_error->code) {
   10894             :       case MS_NOERR:
   10895             :         break;
   10896           0 :       case MS_NOTFOUND:
   10897           0 :         msResetErrorList();
   10898           0 :         break;
   10899             :       case -1:
   10900             :         break;
   10901           0 :       case MS_IOERR:
   10902           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   10903           0 :           _raise_ms_exception();
   10904           0 :           msResetErrorList();
   10905           0 :           return NULL;
   10906             :         }
   10907             :       default:
   10908           0 :         _raise_ms_exception();
   10909           0 :         msResetErrorList();
   10910           0 :         return NULL;
   10911             :       }
   10912             :       
   10913             :     }
   10914             :   }
   10915             :   resultobj = SWIG_Py_Void();
   10916           0 :   return resultobj;
   10917           0 : fail:
   10918             :   return NULL;
   10919             : }
   10920             : 
   10921             : 
   10922           0 : SWIGINTERN PyObject *_wrap_webObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10923             :   PyObject *resultobj = 0;
   10924             :   webObj *arg1 = (webObj *) 0 ;
   10925             :   char *arg2 = (char *) 0 ;
   10926           0 :   void *argp1 = 0 ;
   10927             :   int res1 = 0 ;
   10928             :   int res2 ;
   10929           0 :   char *buf2 = 0 ;
   10930           0 :   int alloc2 = 0 ;
   10931           0 :   PyObject * obj0 = 0 ;
   10932           0 :   PyObject * obj1 = 0 ;
   10933             :   int result;
   10934             :   
   10935           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:webObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   10936           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10937           0 :   if (!SWIG_IsOK(res1)) {
   10938           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_updateFromString" "', argument " "1"" of type '" "webObj *""'"); 
   10939             :   }
   10940           0 :   arg1 = (webObj *)(argp1);
   10941           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10942           0 :   if (!SWIG_IsOK(res2)) {
   10943           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   10944             :   }
   10945           0 :   arg2 = (char *)(buf2);
   10946             :   {
   10947             :     result = (int)webObj_updateFromString(arg1,arg2); {
   10948           0 :       errorObj *ms_error = msGetErrorObj();
   10949             :       
   10950           0 :       switch(ms_error->code) {
   10951             :       case MS_NOERR:
   10952             :         break;
   10953           0 :       case MS_NOTFOUND:
   10954           0 :         msResetErrorList();
   10955           0 :         break;
   10956             :       case -1:
   10957             :         break;
   10958           0 :       case MS_IOERR:
   10959           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   10960           0 :           _raise_ms_exception();
   10961           0 :           msResetErrorList();
   10962           0 :           return NULL;
   10963             :         }
   10964             :       default:
   10965           0 :         _raise_ms_exception();
   10966           0 :         msResetErrorList();
   10967           0 :         return NULL;
   10968             :       }
   10969             :       
   10970             :     }
   10971             :   }
   10972             :   resultobj = SWIG_From_int((int)(result));
   10973           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10974             :   return resultobj;
   10975           0 : fail:
   10976           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   10977             :   return NULL;
   10978             : }
   10979             : 
   10980             : 
   10981           0 : SWIGINTERN PyObject *_wrap_webObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10982             :   PyObject *resultobj = 0;
   10983             :   webObj *arg1 = (webObj *) 0 ;
   10984           0 :   void *argp1 = 0 ;
   10985             :   int res1 = 0 ;
   10986           0 :   PyObject * obj0 = 0 ;
   10987             :   char *result = 0 ;
   10988             :   
   10989           0 :   if (!PyArg_ParseTuple(args,(char *)"O:webObj_convertToString",&obj0)) SWIG_fail;
   10990           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 |  0 );
   10991           0 :   if (!SWIG_IsOK(res1)) {
   10992           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_convertToString" "', argument " "1"" of type '" "webObj *""'"); 
   10993             :   }
   10994           0 :   arg1 = (webObj *)(argp1);
   10995             :   {
   10996             :     result = (char *)webObj_convertToString(arg1); {
   10997           0 :       errorObj *ms_error = msGetErrorObj();
   10998             :       
   10999           0 :       switch(ms_error->code) {
   11000             :       case MS_NOERR:
   11001             :         break;
   11002           0 :       case MS_NOTFOUND:
   11003           0 :         msResetErrorList();
   11004           0 :         break;
   11005             :       case -1:
   11006             :         break;
   11007           0 :       case MS_IOERR:
   11008           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   11009           0 :           _raise_ms_exception();
   11010           0 :           msResetErrorList();
   11011           0 :           return NULL;
   11012             :         }
   11013             :       default:
   11014           0 :         _raise_ms_exception();
   11015           0 :         msResetErrorList();
   11016           0 :         return NULL;
   11017             :       }
   11018             :       
   11019             :     }
   11020             :   }
   11021           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   11022           0 :   free((char*)result);
   11023           0 :   return resultobj;
   11024           0 : fail:
   11025             :   return NULL;
   11026             : }
   11027             : 
   11028             : 
   11029           1 : SWIGINTERN PyObject *webObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11030             :   PyObject *obj;
   11031           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   11032           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_webObj, SWIG_NewClientData(obj));
   11033           1 :   return SWIG_Py_Void();
   11034             : }
   11035             : 
   11036           1 : SWIGINTERN PyObject *_wrap_styleObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11037             :   PyObject *resultobj = 0;
   11038             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11039           1 :   void *argp1 = 0 ;
   11040             :   int res1 = 0 ;
   11041           1 :   PyObject * obj0 = 0 ;
   11042             :   int result;
   11043             :   
   11044           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_refcount_get",&obj0)) SWIG_fail;
   11045           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11046           1 :   if (!SWIG_IsOK(res1)) {
   11047           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_refcount_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11048             :   }
   11049           1 :   arg1 = (struct styleObj *)(argp1);
   11050           1 :   result = (int) ((arg1)->refcount);
   11051             :   resultobj = SWIG_From_int((int)(result));
   11052           1 :   return resultobj;
   11053           0 : fail:
   11054             :   return NULL;
   11055             : }
   11056             : 
   11057             : 
   11058           0 : SWIGINTERN PyObject *_wrap_styleObj_symbolname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11059             :   PyObject *resultobj = 0;
   11060             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11061           0 :   void *argp1 = 0 ;
   11062             :   int res1 = 0 ;
   11063           0 :   PyObject * obj0 = 0 ;
   11064             :   char *result = 0 ;
   11065             :   
   11066           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_symbolname_get",&obj0)) SWIG_fail;
   11067           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11068           0 :   if (!SWIG_IsOK(res1)) {
   11069           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_symbolname_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11070             :   }
   11071           0 :   arg1 = (struct styleObj *)(argp1);
   11072           0 :   result = (char *) ((arg1)->symbolname);
   11073           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   11074           0 :   return resultobj;
   11075           0 : fail:
   11076             :   return NULL;
   11077             : }
   11078             : 
   11079             : 
   11080           0 : SWIGINTERN PyObject *_wrap_styleObj_autoangle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11081             :   PyObject *resultobj = 0;
   11082             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11083             :   int arg2 ;
   11084           0 :   void *argp1 = 0 ;
   11085             :   int res1 = 0 ;
   11086             :   int val2 ;
   11087             :   int ecode2 = 0 ;
   11088           0 :   PyObject * obj0 = 0 ;
   11089           0 :   PyObject * obj1 = 0 ;
   11090             :   
   11091           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_autoangle_set",&obj0,&obj1)) SWIG_fail;
   11092           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11093           0 :   if (!SWIG_IsOK(res1)) {
   11094           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_autoangle_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11095             :   }
   11096           0 :   arg1 = (struct styleObj *)(argp1);
   11097           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   11098           0 :   if (!SWIG_IsOK(ecode2)) {
   11099           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_autoangle_set" "', argument " "2"" of type '" "int""'");
   11100             :   } 
   11101             :   arg2 = (int)(val2);
   11102           0 :   if (arg1) (arg1)->autoangle = arg2;
   11103             :   resultobj = SWIG_Py_Void();
   11104           0 :   return resultobj;
   11105           0 : fail:
   11106             :   return NULL;
   11107             : }
   11108             : 
   11109             : 
   11110           0 : SWIGINTERN PyObject *_wrap_styleObj_autoangle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11111             :   PyObject *resultobj = 0;
   11112             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11113           0 :   void *argp1 = 0 ;
   11114             :   int res1 = 0 ;
   11115           0 :   PyObject * obj0 = 0 ;
   11116             :   int result;
   11117             :   
   11118           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_autoangle_get",&obj0)) SWIG_fail;
   11119           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11120           0 :   if (!SWIG_IsOK(res1)) {
   11121           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_autoangle_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11122             :   }
   11123           0 :   arg1 = (struct styleObj *)(argp1);
   11124           0 :   result = (int) ((arg1)->autoangle);
   11125             :   resultobj = SWIG_From_int((int)(result));
   11126           0 :   return resultobj;
   11127           0 : fail:
   11128             :   return NULL;
   11129             : }
   11130             : 
   11131             : 
   11132           1 : SWIGINTERN PyObject *_wrap_styleObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11133             :   PyObject *resultobj = 0;
   11134             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11135             :   colorObj *arg2 = (colorObj *) 0 ;
   11136           1 :   void *argp1 = 0 ;
   11137             :   int res1 = 0 ;
   11138           1 :   void *argp2 = 0 ;
   11139             :   int res2 = 0 ;
   11140           1 :   PyObject * obj0 = 0 ;
   11141           1 :   PyObject * obj1 = 0 ;
   11142             :   
   11143           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_color_set",&obj0,&obj1)) SWIG_fail;
   11144           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11145           1 :   if (!SWIG_IsOK(res1)) {
   11146           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_color_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11147             :   }
   11148           1 :   arg1 = (struct styleObj *)(argp1);
   11149           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   11150           1 :   if (!SWIG_IsOK(res2)) {
   11151           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_color_set" "', argument " "2"" of type '" "colorObj *""'"); 
   11152             :   }
   11153           1 :   arg2 = (colorObj *)(argp2);
   11154           1 :   if (arg1) (arg1)->color = *arg2;
   11155             :   resultobj = SWIG_Py_Void();
   11156           1 :   return resultobj;
   11157           0 : fail:
   11158             :   return NULL;
   11159             : }
   11160             : 
   11161             : 
   11162           1 : SWIGINTERN PyObject *_wrap_styleObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11163             :   PyObject *resultobj = 0;
   11164             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11165           1 :   void *argp1 = 0 ;
   11166             :   int res1 = 0 ;
   11167           1 :   PyObject * obj0 = 0 ;
   11168             :   colorObj *result = 0 ;
   11169             :   
   11170           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_color_get",&obj0)) SWIG_fail;
   11171           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11172           1 :   if (!SWIG_IsOK(res1)) {
   11173           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_color_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11174             :   }
   11175           1 :   arg1 = (struct styleObj *)(argp1);
   11176           1 :   result = (colorObj *)& ((arg1)->color);
   11177           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   11178           1 :   return resultobj;
   11179           0 : fail:
   11180             :   return NULL;
   11181             : }
   11182             : 
   11183             : 
   11184           0 : SWIGINTERN PyObject *_wrap_styleObj_backgroundcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11185             :   PyObject *resultobj = 0;
   11186             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11187             :   colorObj *arg2 = (colorObj *) 0 ;
   11188           0 :   void *argp1 = 0 ;
   11189             :   int res1 = 0 ;
   11190           0 :   void *argp2 = 0 ;
   11191             :   int res2 = 0 ;
   11192           0 :   PyObject * obj0 = 0 ;
   11193           0 :   PyObject * obj1 = 0 ;
   11194             :   
   11195           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_backgroundcolor_set",&obj0,&obj1)) SWIG_fail;
   11196           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11197           0 :   if (!SWIG_IsOK(res1)) {
   11198           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_backgroundcolor_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11199             :   }
   11200           0 :   arg1 = (struct styleObj *)(argp1);
   11201           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   11202           0 :   if (!SWIG_IsOK(res2)) {
   11203           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_backgroundcolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   11204             :   }
   11205           0 :   arg2 = (colorObj *)(argp2);
   11206           0 :   if (arg1) (arg1)->backgroundcolor = *arg2;
   11207             :   resultobj = SWIG_Py_Void();
   11208           0 :   return resultobj;
   11209           0 : fail:
   11210             :   return NULL;
   11211             : }
   11212             : 
   11213             : 
   11214           0 : SWIGINTERN PyObject *_wrap_styleObj_backgroundcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11215             :   PyObject *resultobj = 0;
   11216             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11217           0 :   void *argp1 = 0 ;
   11218             :   int res1 = 0 ;
   11219           0 :   PyObject * obj0 = 0 ;
   11220             :   colorObj *result = 0 ;
   11221             :   
   11222           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_backgroundcolor_get",&obj0)) SWIG_fail;
   11223           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11224           0 :   if (!SWIG_IsOK(res1)) {
   11225           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_backgroundcolor_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11226             :   }
   11227           0 :   arg1 = (struct styleObj *)(argp1);
   11228           0 :   result = (colorObj *)& ((arg1)->backgroundcolor);
   11229           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   11230           0 :   return resultobj;
   11231           0 : fail:
   11232             :   return NULL;
   11233             : }
   11234             : 
   11235             : 
   11236           0 : SWIGINTERN PyObject *_wrap_styleObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11237             :   PyObject *resultobj = 0;
   11238             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11239             :   colorObj *arg2 = (colorObj *) 0 ;
   11240           0 :   void *argp1 = 0 ;
   11241             :   int res1 = 0 ;
   11242           0 :   void *argp2 = 0 ;
   11243             :   int res2 = 0 ;
   11244           0 :   PyObject * obj0 = 0 ;
   11245           0 :   PyObject * obj1 = 0 ;
   11246             :   
   11247           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
   11248           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11249           0 :   if (!SWIG_IsOK(res1)) {
   11250           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinecolor_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11251             :   }
   11252           0 :   arg1 = (struct styleObj *)(argp1);
   11253           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   11254           0 :   if (!SWIG_IsOK(res2)) {
   11255           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   11256             :   }
   11257           0 :   arg2 = (colorObj *)(argp2);
   11258           0 :   if (arg1) (arg1)->outlinecolor = *arg2;
   11259             :   resultobj = SWIG_Py_Void();
   11260           0 :   return resultobj;
   11261           0 : fail:
   11262             :   return NULL;
   11263             : }
   11264             : 
   11265             : 
   11266           1 : SWIGINTERN PyObject *_wrap_styleObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11267             :   PyObject *resultobj = 0;
   11268             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11269           1 :   void *argp1 = 0 ;
   11270             :   int res1 = 0 ;
   11271           1 :   PyObject * obj0 = 0 ;
   11272             :   colorObj *result = 0 ;
   11273             :   
   11274           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_outlinecolor_get",&obj0)) SWIG_fail;
   11275           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11276           1 :   if (!SWIG_IsOK(res1)) {
   11277           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinecolor_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11278             :   }
   11279           1 :   arg1 = (struct styleObj *)(argp1);
   11280           1 :   result = (colorObj *)& ((arg1)->outlinecolor);
   11281           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   11282           1 :   return resultobj;
   11283           0 : fail:
   11284             :   return NULL;
   11285             : }
   11286             : 
   11287             : 
   11288           0 : SWIGINTERN PyObject *_wrap_styleObj_opacity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11289             :   PyObject *resultobj = 0;
   11290             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11291             :   int arg2 ;
   11292           0 :   void *argp1 = 0 ;
   11293             :   int res1 = 0 ;
   11294             :   int val2 ;
   11295             :   int ecode2 = 0 ;
   11296           0 :   PyObject * obj0 = 0 ;
   11297           0 :   PyObject * obj1 = 0 ;
   11298             :   
   11299           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_opacity_set",&obj0,&obj1)) SWIG_fail;
   11300           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11301           0 :   if (!SWIG_IsOK(res1)) {
   11302           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_opacity_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11303             :   }
   11304           0 :   arg1 = (struct styleObj *)(argp1);
   11305           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   11306           0 :   if (!SWIG_IsOK(ecode2)) {
   11307           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_opacity_set" "', argument " "2"" of type '" "int""'");
   11308             :   } 
   11309             :   arg2 = (int)(val2);
   11310           0 :   if (arg1) (arg1)->opacity = arg2;
   11311             :   resultobj = SWIG_Py_Void();
   11312           0 :   return resultobj;
   11313           0 : fail:
   11314             :   return NULL;
   11315             : }
   11316             : 
   11317             : 
   11318           0 : SWIGINTERN PyObject *_wrap_styleObj_opacity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11319             :   PyObject *resultobj = 0;
   11320             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11321           0 :   void *argp1 = 0 ;
   11322             :   int res1 = 0 ;
   11323           0 :   PyObject * obj0 = 0 ;
   11324             :   int result;
   11325             :   
   11326           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_opacity_get",&obj0)) SWIG_fail;
   11327           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11328           0 :   if (!SWIG_IsOK(res1)) {
   11329           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_opacity_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11330             :   }
   11331           0 :   arg1 = (struct styleObj *)(argp1);
   11332           0 :   result = (int) ((arg1)->opacity);
   11333             :   resultobj = SWIG_From_int((int)(result));
   11334           0 :   return resultobj;
   11335           0 : fail:
   11336             :   return NULL;
   11337             : }
   11338             : 
   11339             : 
   11340           0 : SWIGINTERN PyObject *_wrap_styleObj_mincolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11341             :   PyObject *resultobj = 0;
   11342             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11343             :   colorObj *arg2 = (colorObj *) 0 ;
   11344           0 :   void *argp1 = 0 ;
   11345             :   int res1 = 0 ;
   11346           0 :   void *argp2 = 0 ;
   11347             :   int res2 = 0 ;
   11348           0 :   PyObject * obj0 = 0 ;
   11349           0 :   PyObject * obj1 = 0 ;
   11350             :   
   11351           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_mincolor_set",&obj0,&obj1)) SWIG_fail;
   11352           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11353           0 :   if (!SWIG_IsOK(res1)) {
   11354           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_mincolor_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11355             :   }
   11356           0 :   arg1 = (struct styleObj *)(argp1);
   11357           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   11358           0 :   if (!SWIG_IsOK(res2)) {
   11359           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_mincolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   11360             :   }
   11361           0 :   arg2 = (colorObj *)(argp2);
   11362           0 :   if (arg1) (arg1)->mincolor = *arg2;
   11363             :   resultobj = SWIG_Py_Void();
   11364           0 :   return resultobj;
   11365           0 : fail:
   11366             :   return NULL;
   11367             : }
   11368             : 
   11369             : 
   11370           0 : SWIGINTERN PyObject *_wrap_styleObj_mincolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11371             :   PyObject *resultobj = 0;
   11372             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11373           0 :   void *argp1 = 0 ;
   11374             :   int res1 = 0 ;
   11375           0 :   PyObject * obj0 = 0 ;
   11376             :   colorObj *result = 0 ;
   11377             :   
   11378           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_mincolor_get",&obj0)) SWIG_fail;
   11379           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11380           0 :   if (!SWIG_IsOK(res1)) {
   11381           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_mincolor_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11382             :   }
   11383           0 :   arg1 = (struct styleObj *)(argp1);
   11384           0 :   result = (colorObj *)& ((arg1)->mincolor);
   11385           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   11386           0 :   return resultobj;
   11387           0 : fail:
   11388             :   return NULL;
   11389             : }
   11390             : 
   11391             : 
   11392           0 : SWIGINTERN PyObject *_wrap_styleObj_maxcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11393             :   PyObject *resultobj = 0;
   11394             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11395             :   colorObj *arg2 = (colorObj *) 0 ;
   11396           0 :   void *argp1 = 0 ;
   11397             :   int res1 = 0 ;
   11398           0 :   void *argp2 = 0 ;
   11399             :   int res2 = 0 ;
   11400           0 :   PyObject * obj0 = 0 ;
   11401           0 :   PyObject * obj1 = 0 ;
   11402             :   
   11403           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxcolor_set",&obj0,&obj1)) SWIG_fail;
   11404           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11405           0 :   if (!SWIG_IsOK(res1)) {
   11406           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxcolor_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11407             :   }
   11408           0 :   arg1 = (struct styleObj *)(argp1);
   11409           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   11410           0 :   if (!SWIG_IsOK(res2)) {
   11411           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_maxcolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   11412             :   }
   11413           0 :   arg2 = (colorObj *)(argp2);
   11414           0 :   if (arg1) (arg1)->maxcolor = *arg2;
   11415             :   resultobj = SWIG_Py_Void();
   11416           0 :   return resultobj;
   11417           0 : fail:
   11418             :   return NULL;
   11419             : }
   11420             : 
   11421             : 
   11422           0 : SWIGINTERN PyObject *_wrap_styleObj_maxcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11423             :   PyObject *resultobj = 0;
   11424             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11425           0 :   void *argp1 = 0 ;
   11426             :   int res1 = 0 ;
   11427           0 :   PyObject * obj0 = 0 ;
   11428             :   colorObj *result = 0 ;
   11429             :   
   11430           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxcolor_get",&obj0)) SWIG_fail;
   11431           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11432           0 :   if (!SWIG_IsOK(res1)) {
   11433           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxcolor_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11434             :   }
   11435           0 :   arg1 = (struct styleObj *)(argp1);
   11436           0 :   result = (colorObj *)& ((arg1)->maxcolor);
   11437           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   11438           0 :   return resultobj;
   11439           0 : fail:
   11440             :   return NULL;
   11441             : }
   11442             : 
   11443             : 
   11444           0 : SWIGINTERN PyObject *_wrap_styleObj_minvalue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11445             :   PyObject *resultobj = 0;
   11446             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11447             :   double arg2 ;
   11448           0 :   void *argp1 = 0 ;
   11449             :   int res1 = 0 ;
   11450             :   double val2 ;
   11451             :   int ecode2 = 0 ;
   11452           0 :   PyObject * obj0 = 0 ;
   11453           0 :   PyObject * obj1 = 0 ;
   11454             :   
   11455           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minvalue_set",&obj0,&obj1)) SWIG_fail;
   11456           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11457           0 :   if (!SWIG_IsOK(res1)) {
   11458           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minvalue_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11459             :   }
   11460           0 :   arg1 = (struct styleObj *)(argp1);
   11461           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11462           0 :   if (!SWIG_IsOK(ecode2)) {
   11463           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minvalue_set" "', argument " "2"" of type '" "double""'");
   11464             :   } 
   11465           0 :   arg2 = (double)(val2);
   11466           0 :   if (arg1) (arg1)->minvalue = arg2;
   11467             :   resultobj = SWIG_Py_Void();
   11468           0 :   return resultobj;
   11469           0 : fail:
   11470             :   return NULL;
   11471             : }
   11472             : 
   11473             : 
   11474           0 : SWIGINTERN PyObject *_wrap_styleObj_minvalue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11475             :   PyObject *resultobj = 0;
   11476             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11477           0 :   void *argp1 = 0 ;
   11478             :   int res1 = 0 ;
   11479           0 :   PyObject * obj0 = 0 ;
   11480             :   double result;
   11481             :   
   11482           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minvalue_get",&obj0)) SWIG_fail;
   11483           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11484           0 :   if (!SWIG_IsOK(res1)) {
   11485           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minvalue_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11486             :   }
   11487           0 :   arg1 = (struct styleObj *)(argp1);
   11488           0 :   result = (double) ((arg1)->minvalue);
   11489           0 :   resultobj = SWIG_From_double((double)(result));
   11490           0 :   return resultobj;
   11491           0 : fail:
   11492             :   return NULL;
   11493             : }
   11494             : 
   11495             : 
   11496           0 : SWIGINTERN PyObject *_wrap_styleObj_maxvalue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11497             :   PyObject *resultobj = 0;
   11498             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11499             :   double arg2 ;
   11500           0 :   void *argp1 = 0 ;
   11501             :   int res1 = 0 ;
   11502             :   double val2 ;
   11503             :   int ecode2 = 0 ;
   11504           0 :   PyObject * obj0 = 0 ;
   11505           0 :   PyObject * obj1 = 0 ;
   11506             :   
   11507           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxvalue_set",&obj0,&obj1)) SWIG_fail;
   11508           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11509           0 :   if (!SWIG_IsOK(res1)) {
   11510           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxvalue_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11511             :   }
   11512           0 :   arg1 = (struct styleObj *)(argp1);
   11513           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11514           0 :   if (!SWIG_IsOK(ecode2)) {
   11515           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxvalue_set" "', argument " "2"" of type '" "double""'");
   11516             :   } 
   11517           0 :   arg2 = (double)(val2);
   11518           0 :   if (arg1) (arg1)->maxvalue = arg2;
   11519             :   resultobj = SWIG_Py_Void();
   11520           0 :   return resultobj;
   11521           0 : fail:
   11522             :   return NULL;
   11523             : }
   11524             : 
   11525             : 
   11526           0 : SWIGINTERN PyObject *_wrap_styleObj_maxvalue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11527             :   PyObject *resultobj = 0;
   11528             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11529           0 :   void *argp1 = 0 ;
   11530             :   int res1 = 0 ;
   11531           0 :   PyObject * obj0 = 0 ;
   11532             :   double result;
   11533             :   
   11534           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxvalue_get",&obj0)) SWIG_fail;
   11535           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11536           0 :   if (!SWIG_IsOK(res1)) {
   11537           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxvalue_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11538             :   }
   11539           0 :   arg1 = (struct styleObj *)(argp1);
   11540           0 :   result = (double) ((arg1)->maxvalue);
   11541           0 :   resultobj = SWIG_From_double((double)(result));
   11542           0 :   return resultobj;
   11543           0 : fail:
   11544             :   return NULL;
   11545             : }
   11546             : 
   11547             : 
   11548           0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11549             :   PyObject *resultobj = 0;
   11550             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11551             :   char *arg2 = (char *) 0 ;
   11552           0 :   void *argp1 = 0 ;
   11553             :   int res1 = 0 ;
   11554             :   int res2 ;
   11555           0 :   char *buf2 = 0 ;
   11556           0 :   int alloc2 = 0 ;
   11557           0 :   PyObject * obj0 = 0 ;
   11558           0 :   PyObject * obj1 = 0 ;
   11559             :   
   11560           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_rangeitem_set",&obj0,&obj1)) SWIG_fail;
   11561           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11562           0 :   if (!SWIG_IsOK(res1)) {
   11563           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitem_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11564             :   }
   11565           0 :   arg1 = (struct styleObj *)(argp1);
   11566           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   11567           0 :   if (!SWIG_IsOK(res2)) {
   11568           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_rangeitem_set" "', argument " "2"" of type '" "char *""'");
   11569             :   }
   11570           0 :   arg2 = (char *)(buf2);
   11571             :   {
   11572           0 :     if (arg1->rangeitem) free((char*)arg1->rangeitem);
   11573           0 :     if (arg2) {
   11574           0 :       arg1->rangeitem = (char *) malloc(strlen(arg2)+1);
   11575             :       strcpy((char*)arg1->rangeitem,arg2);
   11576             :     } else {
   11577           0 :       arg1->rangeitem = 0;
   11578             :     }
   11579             :   }
   11580             :   resultobj = SWIG_Py_Void();
   11581           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   11582             :   return resultobj;
   11583           0 : fail:
   11584           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   11585             :   return NULL;
   11586             : }
   11587             : 
   11588             : 
   11589           0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11590             :   PyObject *resultobj = 0;
   11591             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11592           0 :   void *argp1 = 0 ;
   11593             :   int res1 = 0 ;
   11594           0 :   PyObject * obj0 = 0 ;
   11595             :   char *result = 0 ;
   11596             :   
   11597           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_rangeitem_get",&obj0)) SWIG_fail;
   11598           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11599           0 :   if (!SWIG_IsOK(res1)) {
   11600           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitem_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11601             :   }
   11602           0 :   arg1 = (struct styleObj *)(argp1);
   11603           0 :   result = (char *) ((arg1)->rangeitem);
   11604           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   11605           0 :   return resultobj;
   11606           0 : fail:
   11607             :   return NULL;
   11608             : }
   11609             : 
   11610             : 
   11611           0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitemindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11612             :   PyObject *resultobj = 0;
   11613             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11614             :   int arg2 ;
   11615           0 :   void *argp1 = 0 ;
   11616             :   int res1 = 0 ;
   11617             :   int val2 ;
   11618             :   int ecode2 = 0 ;
   11619           0 :   PyObject * obj0 = 0 ;
   11620           0 :   PyObject * obj1 = 0 ;
   11621             :   
   11622           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_rangeitemindex_set",&obj0,&obj1)) SWIG_fail;
   11623           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11624           0 :   if (!SWIG_IsOK(res1)) {
   11625           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitemindex_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11626             :   }
   11627           0 :   arg1 = (struct styleObj *)(argp1);
   11628           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   11629           0 :   if (!SWIG_IsOK(ecode2)) {
   11630           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_rangeitemindex_set" "', argument " "2"" of type '" "int""'");
   11631             :   } 
   11632             :   arg2 = (int)(val2);
   11633           0 :   if (arg1) (arg1)->rangeitemindex = arg2;
   11634             :   resultobj = SWIG_Py_Void();
   11635           0 :   return resultobj;
   11636           0 : fail:
   11637             :   return NULL;
   11638             : }
   11639             : 
   11640             : 
   11641           0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitemindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11642             :   PyObject *resultobj = 0;
   11643             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11644           0 :   void *argp1 = 0 ;
   11645             :   int res1 = 0 ;
   11646           0 :   PyObject * obj0 = 0 ;
   11647             :   int result;
   11648             :   
   11649           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_rangeitemindex_get",&obj0)) SWIG_fail;
   11650           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11651           0 :   if (!SWIG_IsOK(res1)) {
   11652           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitemindex_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11653             :   }
   11654           0 :   arg1 = (struct styleObj *)(argp1);
   11655           0 :   result = (int) ((arg1)->rangeitemindex);
   11656             :   resultobj = SWIG_From_int((int)(result));
   11657           0 :   return resultobj;
   11658           0 : fail:
   11659             :   return NULL;
   11660             : }
   11661             : 
   11662             : 
   11663           1 : SWIGINTERN PyObject *_wrap_styleObj_symbol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11664             :   PyObject *resultobj = 0;
   11665             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11666             :   int arg2 ;
   11667           1 :   void *argp1 = 0 ;
   11668             :   int res1 = 0 ;
   11669             :   int val2 ;
   11670             :   int ecode2 = 0 ;
   11671           1 :   PyObject * obj0 = 0 ;
   11672           1 :   PyObject * obj1 = 0 ;
   11673             :   
   11674           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_symbol_set",&obj0,&obj1)) SWIG_fail;
   11675           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11676           1 :   if (!SWIG_IsOK(res1)) {
   11677           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_symbol_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11678             :   }
   11679           1 :   arg1 = (struct styleObj *)(argp1);
   11680           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   11681           1 :   if (!SWIG_IsOK(ecode2)) {
   11682           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_symbol_set" "', argument " "2"" of type '" "int""'");
   11683             :   } 
   11684             :   arg2 = (int)(val2);
   11685           1 :   if (arg1) (arg1)->symbol = arg2;
   11686             :   resultobj = SWIG_Py_Void();
   11687           1 :   return resultobj;
   11688           0 : fail:
   11689             :   return NULL;
   11690             : }
   11691             : 
   11692             : 
   11693           1 : SWIGINTERN PyObject *_wrap_styleObj_symbol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11694             :   PyObject *resultobj = 0;
   11695             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11696           1 :   void *argp1 = 0 ;
   11697             :   int res1 = 0 ;
   11698           1 :   PyObject * obj0 = 0 ;
   11699             :   int result;
   11700             :   
   11701           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_symbol_get",&obj0)) SWIG_fail;
   11702           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11703           1 :   if (!SWIG_IsOK(res1)) {
   11704           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_symbol_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11705             :   }
   11706           1 :   arg1 = (struct styleObj *)(argp1);
   11707           1 :   result = (int) ((arg1)->symbol);
   11708             :   resultobj = SWIG_From_int((int)(result));
   11709           1 :   return resultobj;
   11710           0 : fail:
   11711             :   return NULL;
   11712             : }
   11713             : 
   11714             : 
   11715           1 : SWIGINTERN PyObject *_wrap_styleObj_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11716             :   PyObject *resultobj = 0;
   11717             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11718             :   double arg2 ;
   11719           1 :   void *argp1 = 0 ;
   11720             :   int res1 = 0 ;
   11721             :   double val2 ;
   11722             :   int ecode2 = 0 ;
   11723           1 :   PyObject * obj0 = 0 ;
   11724           1 :   PyObject * obj1 = 0 ;
   11725             :   
   11726           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_size_set",&obj0,&obj1)) SWIG_fail;
   11727           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11728           1 :   if (!SWIG_IsOK(res1)) {
   11729           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_size_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11730             :   }
   11731           1 :   arg1 = (struct styleObj *)(argp1);
   11732           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11733           1 :   if (!SWIG_IsOK(ecode2)) {
   11734           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_size_set" "', argument " "2"" of type '" "double""'");
   11735             :   } 
   11736           1 :   arg2 = (double)(val2);
   11737           1 :   if (arg1) (arg1)->size = arg2;
   11738             :   resultobj = SWIG_Py_Void();
   11739           1 :   return resultobj;
   11740           0 : fail:
   11741             :   return NULL;
   11742             : }
   11743             : 
   11744             : 
   11745           1 : SWIGINTERN PyObject *_wrap_styleObj_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11746             :   PyObject *resultobj = 0;
   11747             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11748           1 :   void *argp1 = 0 ;
   11749             :   int res1 = 0 ;
   11750           1 :   PyObject * obj0 = 0 ;
   11751             :   double result;
   11752             :   
   11753           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_size_get",&obj0)) SWIG_fail;
   11754           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11755           1 :   if (!SWIG_IsOK(res1)) {
   11756           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_size_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11757             :   }
   11758           1 :   arg1 = (struct styleObj *)(argp1);
   11759           1 :   result = (double) ((arg1)->size);
   11760           1 :   resultobj = SWIG_From_double((double)(result));
   11761           1 :   return resultobj;
   11762           0 : fail:
   11763             :   return NULL;
   11764             : }
   11765             : 
   11766             : 
   11767           0 : SWIGINTERN PyObject *_wrap_styleObj_minsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11768             :   PyObject *resultobj = 0;
   11769             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11770             :   double arg2 ;
   11771           0 :   void *argp1 = 0 ;
   11772             :   int res1 = 0 ;
   11773             :   double val2 ;
   11774             :   int ecode2 = 0 ;
   11775           0 :   PyObject * obj0 = 0 ;
   11776           0 :   PyObject * obj1 = 0 ;
   11777             :   
   11778           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minsize_set",&obj0,&obj1)) SWIG_fail;
   11779           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11780           0 :   if (!SWIG_IsOK(res1)) {
   11781           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minsize_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11782             :   }
   11783           0 :   arg1 = (struct styleObj *)(argp1);
   11784           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11785           0 :   if (!SWIG_IsOK(ecode2)) {
   11786           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minsize_set" "', argument " "2"" of type '" "double""'");
   11787             :   } 
   11788           0 :   arg2 = (double)(val2);
   11789           0 :   if (arg1) (arg1)->minsize = arg2;
   11790             :   resultobj = SWIG_Py_Void();
   11791           0 :   return resultobj;
   11792           0 : fail:
   11793             :   return NULL;
   11794             : }
   11795             : 
   11796             : 
   11797           0 : SWIGINTERN PyObject *_wrap_styleObj_minsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11798             :   PyObject *resultobj = 0;
   11799             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11800           0 :   void *argp1 = 0 ;
   11801             :   int res1 = 0 ;
   11802           0 :   PyObject * obj0 = 0 ;
   11803             :   double result;
   11804             :   
   11805           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minsize_get",&obj0)) SWIG_fail;
   11806           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11807           0 :   if (!SWIG_IsOK(res1)) {
   11808           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minsize_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11809             :   }
   11810           0 :   arg1 = (struct styleObj *)(argp1);
   11811           0 :   result = (double) ((arg1)->minsize);
   11812           0 :   resultobj = SWIG_From_double((double)(result));
   11813           0 :   return resultobj;
   11814           0 : fail:
   11815             :   return NULL;
   11816             : }
   11817             : 
   11818             : 
   11819           0 : SWIGINTERN PyObject *_wrap_styleObj_maxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11820             :   PyObject *resultobj = 0;
   11821             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11822             :   double arg2 ;
   11823           0 :   void *argp1 = 0 ;
   11824             :   int res1 = 0 ;
   11825             :   double val2 ;
   11826             :   int ecode2 = 0 ;
   11827           0 :   PyObject * obj0 = 0 ;
   11828           0 :   PyObject * obj1 = 0 ;
   11829             :   
   11830           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxsize_set",&obj0,&obj1)) SWIG_fail;
   11831           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11832           0 :   if (!SWIG_IsOK(res1)) {
   11833           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxsize_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11834             :   }
   11835           0 :   arg1 = (struct styleObj *)(argp1);
   11836           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11837           0 :   if (!SWIG_IsOK(ecode2)) {
   11838           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxsize_set" "', argument " "2"" of type '" "double""'");
   11839             :   } 
   11840           0 :   arg2 = (double)(val2);
   11841           0 :   if (arg1) (arg1)->maxsize = arg2;
   11842             :   resultobj = SWIG_Py_Void();
   11843           0 :   return resultobj;
   11844           0 : fail:
   11845             :   return NULL;
   11846             : }
   11847             : 
   11848             : 
   11849           0 : SWIGINTERN PyObject *_wrap_styleObj_maxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11850             :   PyObject *resultobj = 0;
   11851             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11852           0 :   void *argp1 = 0 ;
   11853             :   int res1 = 0 ;
   11854           0 :   PyObject * obj0 = 0 ;
   11855             :   double result;
   11856             :   
   11857           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxsize_get",&obj0)) SWIG_fail;
   11858           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11859           0 :   if (!SWIG_IsOK(res1)) {
   11860           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxsize_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11861             :   }
   11862           0 :   arg1 = (struct styleObj *)(argp1);
   11863           0 :   result = (double) ((arg1)->maxsize);
   11864           0 :   resultobj = SWIG_From_double((double)(result));
   11865           0 :   return resultobj;
   11866           0 : fail:
   11867             :   return NULL;
   11868             : }
   11869             : 
   11870             : 
   11871           1 : SWIGINTERN PyObject *_wrap_styleObj_patternlength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11872             :   PyObject *resultobj = 0;
   11873             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11874           1 :   void *argp1 = 0 ;
   11875             :   int res1 = 0 ;
   11876           1 :   PyObject * obj0 = 0 ;
   11877             :   int result;
   11878             :   
   11879           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_patternlength_get",&obj0)) SWIG_fail;
   11880           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11881           1 :   if (!SWIG_IsOK(res1)) {
   11882           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_patternlength_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11883             :   }
   11884           1 :   arg1 = (struct styleObj *)(argp1);
   11885           1 :   result = (int) ((arg1)->patternlength);
   11886             :   resultobj = SWIG_From_int((int)(result));
   11887           1 :   return resultobj;
   11888           0 : fail:
   11889             :   return NULL;
   11890             : }
   11891             : 
   11892             : 
   11893           0 : SWIGINTERN PyObject *_wrap_styleObj_gap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11894             :   PyObject *resultobj = 0;
   11895             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11896             :   double arg2 ;
   11897           0 :   void *argp1 = 0 ;
   11898             :   int res1 = 0 ;
   11899             :   double val2 ;
   11900             :   int ecode2 = 0 ;
   11901           0 :   PyObject * obj0 = 0 ;
   11902           0 :   PyObject * obj1 = 0 ;
   11903             :   
   11904           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_gap_set",&obj0,&obj1)) SWIG_fail;
   11905           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11906           0 :   if (!SWIG_IsOK(res1)) {
   11907           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_gap_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11908             :   }
   11909           0 :   arg1 = (struct styleObj *)(argp1);
   11910           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11911           0 :   if (!SWIG_IsOK(ecode2)) {
   11912           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_gap_set" "', argument " "2"" of type '" "double""'");
   11913             :   } 
   11914           0 :   arg2 = (double)(val2);
   11915           0 :   if (arg1) (arg1)->gap = arg2;
   11916             :   resultobj = SWIG_Py_Void();
   11917           0 :   return resultobj;
   11918           0 : fail:
   11919             :   return NULL;
   11920             : }
   11921             : 
   11922             : 
   11923           0 : SWIGINTERN PyObject *_wrap_styleObj_gap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11924             :   PyObject *resultobj = 0;
   11925             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11926           0 :   void *argp1 = 0 ;
   11927             :   int res1 = 0 ;
   11928           0 :   PyObject * obj0 = 0 ;
   11929             :   double result;
   11930             :   
   11931           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_gap_get",&obj0)) SWIG_fail;
   11932           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11933           0 :   if (!SWIG_IsOK(res1)) {
   11934           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_gap_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11935             :   }
   11936           0 :   arg1 = (struct styleObj *)(argp1);
   11937           0 :   result = (double) ((arg1)->gap);
   11938           0 :   resultobj = SWIG_From_double((double)(result));
   11939           0 :   return resultobj;
   11940           0 : fail:
   11941             :   return NULL;
   11942             : }
   11943             : 
   11944             : 
   11945           0 : SWIGINTERN PyObject *_wrap_styleObj_initialgap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11946             :   PyObject *resultobj = 0;
   11947             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11948             :   double arg2 ;
   11949           0 :   void *argp1 = 0 ;
   11950             :   int res1 = 0 ;
   11951             :   double val2 ;
   11952             :   int ecode2 = 0 ;
   11953           0 :   PyObject * obj0 = 0 ;
   11954           0 :   PyObject * obj1 = 0 ;
   11955             :   
   11956           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_initialgap_set",&obj0,&obj1)) SWIG_fail;
   11957           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11958           0 :   if (!SWIG_IsOK(res1)) {
   11959           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_initialgap_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11960             :   }
   11961           0 :   arg1 = (struct styleObj *)(argp1);
   11962           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   11963           0 :   if (!SWIG_IsOK(ecode2)) {
   11964           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_initialgap_set" "', argument " "2"" of type '" "double""'");
   11965             :   } 
   11966           0 :   arg2 = (double)(val2);
   11967           0 :   if (arg1) (arg1)->initialgap = arg2;
   11968             :   resultobj = SWIG_Py_Void();
   11969           0 :   return resultobj;
   11970           0 : fail:
   11971             :   return NULL;
   11972             : }
   11973             : 
   11974             : 
   11975           0 : SWIGINTERN PyObject *_wrap_styleObj_initialgap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11976             :   PyObject *resultobj = 0;
   11977             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   11978           0 :   void *argp1 = 0 ;
   11979             :   int res1 = 0 ;
   11980           0 :   PyObject * obj0 = 0 ;
   11981             :   double result;
   11982             :   
   11983           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_initialgap_get",&obj0)) SWIG_fail;
   11984           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   11985           0 :   if (!SWIG_IsOK(res1)) {
   11986           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_initialgap_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   11987             :   }
   11988           0 :   arg1 = (struct styleObj *)(argp1);
   11989           0 :   result = (double) ((arg1)->initialgap);
   11990           0 :   resultobj = SWIG_From_double((double)(result));
   11991           0 :   return resultobj;
   11992           0 : fail:
   11993             :   return NULL;
   11994             : }
   11995             : 
   11996             : 
   11997           0 : SWIGINTERN PyObject *_wrap_styleObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   11998             :   PyObject *resultobj = 0;
   11999             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12000             :   int arg2 ;
   12001           0 :   void *argp1 = 0 ;
   12002             :   int res1 = 0 ;
   12003             :   int val2 ;
   12004             :   int ecode2 = 0 ;
   12005           0 :   PyObject * obj0 = 0 ;
   12006           0 :   PyObject * obj1 = 0 ;
   12007             :   
   12008           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_position_set",&obj0,&obj1)) SWIG_fail;
   12009           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12010           0 :   if (!SWIG_IsOK(res1)) {
   12011           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_position_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12012             :   }
   12013           0 :   arg1 = (struct styleObj *)(argp1);
   12014           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   12015           0 :   if (!SWIG_IsOK(ecode2)) {
   12016           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_position_set" "', argument " "2"" of type '" "int""'");
   12017             :   } 
   12018             :   arg2 = (int)(val2);
   12019           0 :   if (arg1) (arg1)->position = arg2;
   12020             :   resultobj = SWIG_Py_Void();
   12021           0 :   return resultobj;
   12022           0 : fail:
   12023             :   return NULL;
   12024             : }
   12025             : 
   12026             : 
   12027           0 : SWIGINTERN PyObject *_wrap_styleObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12028             :   PyObject *resultobj = 0;
   12029             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12030           0 :   void *argp1 = 0 ;
   12031             :   int res1 = 0 ;
   12032           0 :   PyObject * obj0 = 0 ;
   12033             :   int result;
   12034             :   
   12035           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_position_get",&obj0)) SWIG_fail;
   12036           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12037           0 :   if (!SWIG_IsOK(res1)) {
   12038           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_position_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12039             :   }
   12040           0 :   arg1 = (struct styleObj *)(argp1);
   12041           0 :   result = (int) ((arg1)->position);
   12042             :   resultobj = SWIG_From_int((int)(result));
   12043           0 :   return resultobj;
   12044           0 : fail:
   12045             :   return NULL;
   12046             : }
   12047             : 
   12048             : 
   12049           0 : SWIGINTERN PyObject *_wrap_styleObj_linecap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12050             :   PyObject *resultobj = 0;
   12051             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12052             :   int arg2 ;
   12053           0 :   void *argp1 = 0 ;
   12054             :   int res1 = 0 ;
   12055             :   int val2 ;
   12056             :   int ecode2 = 0 ;
   12057           0 :   PyObject * obj0 = 0 ;
   12058           0 :   PyObject * obj1 = 0 ;
   12059             :   
   12060           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_linecap_set",&obj0,&obj1)) SWIG_fail;
   12061           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12062           0 :   if (!SWIG_IsOK(res1)) {
   12063           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linecap_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12064             :   }
   12065           0 :   arg1 = (struct styleObj *)(argp1);
   12066           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   12067           0 :   if (!SWIG_IsOK(ecode2)) {
   12068           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_linecap_set" "', argument " "2"" of type '" "int""'");
   12069             :   } 
   12070             :   arg2 = (int)(val2);
   12071           0 :   if (arg1) (arg1)->linecap = arg2;
   12072             :   resultobj = SWIG_Py_Void();
   12073           0 :   return resultobj;
   12074           0 : fail:
   12075             :   return NULL;
   12076             : }
   12077             : 
   12078             : 
   12079           0 : SWIGINTERN PyObject *_wrap_styleObj_linecap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12080             :   PyObject *resultobj = 0;
   12081             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12082           0 :   void *argp1 = 0 ;
   12083             :   int res1 = 0 ;
   12084           0 :   PyObject * obj0 = 0 ;
   12085             :   int result;
   12086             :   
   12087           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_linecap_get",&obj0)) SWIG_fail;
   12088           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12089           0 :   if (!SWIG_IsOK(res1)) {
   12090           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linecap_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12091             :   }
   12092           0 :   arg1 = (struct styleObj *)(argp1);
   12093           0 :   result = (int) ((arg1)->linecap);
   12094             :   resultobj = SWIG_From_int((int)(result));
   12095           0 :   return resultobj;
   12096           0 : fail:
   12097             :   return NULL;
   12098             : }
   12099             : 
   12100             : 
   12101           0 : SWIGINTERN PyObject *_wrap_styleObj_linejoin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12102             :   PyObject *resultobj = 0;
   12103             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12104             :   int arg2 ;
   12105           0 :   void *argp1 = 0 ;
   12106             :   int res1 = 0 ;
   12107             :   int val2 ;
   12108             :   int ecode2 = 0 ;
   12109           0 :   PyObject * obj0 = 0 ;
   12110           0 :   PyObject * obj1 = 0 ;
   12111             :   
   12112           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_linejoin_set",&obj0,&obj1)) SWIG_fail;
   12113           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12114           0 :   if (!SWIG_IsOK(res1)) {
   12115           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoin_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12116             :   }
   12117           0 :   arg1 = (struct styleObj *)(argp1);
   12118           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   12119           0 :   if (!SWIG_IsOK(ecode2)) {
   12120           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_linejoin_set" "', argument " "2"" of type '" "int""'");
   12121             :   } 
   12122             :   arg2 = (int)(val2);
   12123           0 :   if (arg1) (arg1)->linejoin = arg2;
   12124             :   resultobj = SWIG_Py_Void();
   12125           0 :   return resultobj;
   12126           0 : fail:
   12127             :   return NULL;
   12128             : }
   12129             : 
   12130             : 
   12131           0 : SWIGINTERN PyObject *_wrap_styleObj_linejoin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12132             :   PyObject *resultobj = 0;
   12133             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12134           0 :   void *argp1 = 0 ;
   12135             :   int res1 = 0 ;
   12136           0 :   PyObject * obj0 = 0 ;
   12137             :   int result;
   12138             :   
   12139           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_linejoin_get",&obj0)) SWIG_fail;
   12140           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12141           0 :   if (!SWIG_IsOK(res1)) {
   12142           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoin_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12143             :   }
   12144           0 :   arg1 = (struct styleObj *)(argp1);
   12145           0 :   result = (int) ((arg1)->linejoin);
   12146             :   resultobj = SWIG_From_int((int)(result));
   12147           0 :   return resultobj;
   12148           0 : fail:
   12149             :   return NULL;
   12150             : }
   12151             : 
   12152             : 
   12153           0 : SWIGINTERN PyObject *_wrap_styleObj_linejoinmaxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12154             :   PyObject *resultobj = 0;
   12155             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12156             :   double arg2 ;
   12157           0 :   void *argp1 = 0 ;
   12158             :   int res1 = 0 ;
   12159             :   double val2 ;
   12160             :   int ecode2 = 0 ;
   12161           0 :   PyObject * obj0 = 0 ;
   12162           0 :   PyObject * obj1 = 0 ;
   12163             :   
   12164           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_linejoinmaxsize_set",&obj0,&obj1)) SWIG_fail;
   12165           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12166           0 :   if (!SWIG_IsOK(res1)) {
   12167           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoinmaxsize_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12168             :   }
   12169           0 :   arg1 = (struct styleObj *)(argp1);
   12170           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12171           0 :   if (!SWIG_IsOK(ecode2)) {
   12172           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_linejoinmaxsize_set" "', argument " "2"" of type '" "double""'");
   12173             :   } 
   12174           0 :   arg2 = (double)(val2);
   12175           0 :   if (arg1) (arg1)->linejoinmaxsize = arg2;
   12176             :   resultobj = SWIG_Py_Void();
   12177           0 :   return resultobj;
   12178           0 : fail:
   12179             :   return NULL;
   12180             : }
   12181             : 
   12182             : 
   12183           0 : SWIGINTERN PyObject *_wrap_styleObj_linejoinmaxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12184             :   PyObject *resultobj = 0;
   12185             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12186           0 :   void *argp1 = 0 ;
   12187             :   int res1 = 0 ;
   12188           0 :   PyObject * obj0 = 0 ;
   12189             :   double result;
   12190             :   
   12191           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_linejoinmaxsize_get",&obj0)) SWIG_fail;
   12192           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12193           0 :   if (!SWIG_IsOK(res1)) {
   12194           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoinmaxsize_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12195             :   }
   12196           0 :   arg1 = (struct styleObj *)(argp1);
   12197           0 :   result = (double) ((arg1)->linejoinmaxsize);
   12198           0 :   resultobj = SWIG_From_double((double)(result));
   12199           0 :   return resultobj;
   12200           0 : fail:
   12201             :   return NULL;
   12202             : }
   12203             : 
   12204             : 
   12205           0 : SWIGINTERN PyObject *_wrap_styleObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12206             :   PyObject *resultobj = 0;
   12207             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12208             :   double arg2 ;
   12209           0 :   void *argp1 = 0 ;
   12210             :   int res1 = 0 ;
   12211             :   double val2 ;
   12212             :   int ecode2 = 0 ;
   12213           0 :   PyObject * obj0 = 0 ;
   12214           0 :   PyObject * obj1 = 0 ;
   12215             :   
   12216           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_width_set",&obj0,&obj1)) SWIG_fail;
   12217           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12218           0 :   if (!SWIG_IsOK(res1)) {
   12219           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_width_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12220             :   }
   12221           0 :   arg1 = (struct styleObj *)(argp1);
   12222           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12223           0 :   if (!SWIG_IsOK(ecode2)) {
   12224           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_width_set" "', argument " "2"" of type '" "double""'");
   12225             :   } 
   12226           0 :   arg2 = (double)(val2);
   12227           0 :   if (arg1) (arg1)->width = arg2;
   12228             :   resultobj = SWIG_Py_Void();
   12229           0 :   return resultobj;
   12230           0 : fail:
   12231             :   return NULL;
   12232             : }
   12233             : 
   12234             : 
   12235           0 : SWIGINTERN PyObject *_wrap_styleObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12236             :   PyObject *resultobj = 0;
   12237             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12238           0 :   void *argp1 = 0 ;
   12239             :   int res1 = 0 ;
   12240           0 :   PyObject * obj0 = 0 ;
   12241             :   double result;
   12242             :   
   12243           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_width_get",&obj0)) SWIG_fail;
   12244           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12245           0 :   if (!SWIG_IsOK(res1)) {
   12246           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_width_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12247             :   }
   12248           0 :   arg1 = (struct styleObj *)(argp1);
   12249           0 :   result = (double) ((arg1)->width);
   12250           0 :   resultobj = SWIG_From_double((double)(result));
   12251           0 :   return resultobj;
   12252           0 : fail:
   12253             :   return NULL;
   12254             : }
   12255             : 
   12256             : 
   12257           0 : SWIGINTERN PyObject *_wrap_styleObj_outlinewidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12258             :   PyObject *resultobj = 0;
   12259             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12260             :   double arg2 ;
   12261           0 :   void *argp1 = 0 ;
   12262             :   int res1 = 0 ;
   12263             :   double val2 ;
   12264             :   int ecode2 = 0 ;
   12265           0 :   PyObject * obj0 = 0 ;
   12266           0 :   PyObject * obj1 = 0 ;
   12267             :   
   12268           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_outlinewidth_set",&obj0,&obj1)) SWIG_fail;
   12269           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12270           0 :   if (!SWIG_IsOK(res1)) {
   12271           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinewidth_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12272             :   }
   12273           0 :   arg1 = (struct styleObj *)(argp1);
   12274           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12275           0 :   if (!SWIG_IsOK(ecode2)) {
   12276           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_outlinewidth_set" "', argument " "2"" of type '" "double""'");
   12277             :   } 
   12278           0 :   arg2 = (double)(val2);
   12279           0 :   if (arg1) (arg1)->outlinewidth = arg2;
   12280             :   resultobj = SWIG_Py_Void();
   12281           0 :   return resultobj;
   12282           0 : fail:
   12283             :   return NULL;
   12284             : }
   12285             : 
   12286             : 
   12287           0 : SWIGINTERN PyObject *_wrap_styleObj_outlinewidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12288             :   PyObject *resultobj = 0;
   12289             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12290           0 :   void *argp1 = 0 ;
   12291             :   int res1 = 0 ;
   12292           0 :   PyObject * obj0 = 0 ;
   12293             :   double result;
   12294             :   
   12295           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_outlinewidth_get",&obj0)) SWIG_fail;
   12296           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12297           0 :   if (!SWIG_IsOK(res1)) {
   12298           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinewidth_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12299             :   }
   12300           0 :   arg1 = (struct styleObj *)(argp1);
   12301           0 :   result = (double) ((arg1)->outlinewidth);
   12302           0 :   resultobj = SWIG_From_double((double)(result));
   12303           0 :   return resultobj;
   12304           0 : fail:
   12305             :   return NULL;
   12306             : }
   12307             : 
   12308             : 
   12309           0 : SWIGINTERN PyObject *_wrap_styleObj_minwidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12310             :   PyObject *resultobj = 0;
   12311             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12312             :   double arg2 ;
   12313           0 :   void *argp1 = 0 ;
   12314             :   int res1 = 0 ;
   12315             :   double val2 ;
   12316             :   int ecode2 = 0 ;
   12317           0 :   PyObject * obj0 = 0 ;
   12318           0 :   PyObject * obj1 = 0 ;
   12319             :   
   12320           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minwidth_set",&obj0,&obj1)) SWIG_fail;
   12321           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12322           0 :   if (!SWIG_IsOK(res1)) {
   12323           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minwidth_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12324             :   }
   12325           0 :   arg1 = (struct styleObj *)(argp1);
   12326           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12327           0 :   if (!SWIG_IsOK(ecode2)) {
   12328           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minwidth_set" "', argument " "2"" of type '" "double""'");
   12329             :   } 
   12330           0 :   arg2 = (double)(val2);
   12331           0 :   if (arg1) (arg1)->minwidth = arg2;
   12332             :   resultobj = SWIG_Py_Void();
   12333           0 :   return resultobj;
   12334           0 : fail:
   12335             :   return NULL;
   12336             : }
   12337             : 
   12338             : 
   12339           0 : SWIGINTERN PyObject *_wrap_styleObj_minwidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12340             :   PyObject *resultobj = 0;
   12341             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12342           0 :   void *argp1 = 0 ;
   12343             :   int res1 = 0 ;
   12344           0 :   PyObject * obj0 = 0 ;
   12345             :   double result;
   12346             :   
   12347           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minwidth_get",&obj0)) SWIG_fail;
   12348           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12349           0 :   if (!SWIG_IsOK(res1)) {
   12350           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minwidth_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12351             :   }
   12352           0 :   arg1 = (struct styleObj *)(argp1);
   12353           0 :   result = (double) ((arg1)->minwidth);
   12354           0 :   resultobj = SWIG_From_double((double)(result));
   12355           0 :   return resultobj;
   12356           0 : fail:
   12357             :   return NULL;
   12358             : }
   12359             : 
   12360             : 
   12361           0 : SWIGINTERN PyObject *_wrap_styleObj_maxwidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12362             :   PyObject *resultobj = 0;
   12363             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12364             :   double arg2 ;
   12365           0 :   void *argp1 = 0 ;
   12366             :   int res1 = 0 ;
   12367             :   double val2 ;
   12368             :   int ecode2 = 0 ;
   12369           0 :   PyObject * obj0 = 0 ;
   12370           0 :   PyObject * obj1 = 0 ;
   12371             :   
   12372           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxwidth_set",&obj0,&obj1)) SWIG_fail;
   12373           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12374           0 :   if (!SWIG_IsOK(res1)) {
   12375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxwidth_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12376             :   }
   12377           0 :   arg1 = (struct styleObj *)(argp1);
   12378           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12379           0 :   if (!SWIG_IsOK(ecode2)) {
   12380           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxwidth_set" "', argument " "2"" of type '" "double""'");
   12381             :   } 
   12382           0 :   arg2 = (double)(val2);
   12383           0 :   if (arg1) (arg1)->maxwidth = arg2;
   12384             :   resultobj = SWIG_Py_Void();
   12385           0 :   return resultobj;
   12386           0 : fail:
   12387             :   return NULL;
   12388             : }
   12389             : 
   12390             : 
   12391           0 : SWIGINTERN PyObject *_wrap_styleObj_maxwidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12392             :   PyObject *resultobj = 0;
   12393             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12394           0 :   void *argp1 = 0 ;
   12395             :   int res1 = 0 ;
   12396           0 :   PyObject * obj0 = 0 ;
   12397             :   double result;
   12398             :   
   12399           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxwidth_get",&obj0)) SWIG_fail;
   12400           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12401           0 :   if (!SWIG_IsOK(res1)) {
   12402           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxwidth_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12403             :   }
   12404           0 :   arg1 = (struct styleObj *)(argp1);
   12405           0 :   result = (double) ((arg1)->maxwidth);
   12406           0 :   resultobj = SWIG_From_double((double)(result));
   12407           0 :   return resultobj;
   12408           0 : fail:
   12409             :   return NULL;
   12410             : }
   12411             : 
   12412             : 
   12413           0 : SWIGINTERN PyObject *_wrap_styleObj_offsetx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12414             :   PyObject *resultobj = 0;
   12415             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12416             :   double arg2 ;
   12417           0 :   void *argp1 = 0 ;
   12418             :   int res1 = 0 ;
   12419             :   double val2 ;
   12420             :   int ecode2 = 0 ;
   12421           0 :   PyObject * obj0 = 0 ;
   12422           0 :   PyObject * obj1 = 0 ;
   12423             :   
   12424           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_offsetx_set",&obj0,&obj1)) SWIG_fail;
   12425           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12426           0 :   if (!SWIG_IsOK(res1)) {
   12427           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsetx_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12428             :   }
   12429           0 :   arg1 = (struct styleObj *)(argp1);
   12430           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12431           0 :   if (!SWIG_IsOK(ecode2)) {
   12432           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_offsetx_set" "', argument " "2"" of type '" "double""'");
   12433             :   } 
   12434           0 :   arg2 = (double)(val2);
   12435           0 :   if (arg1) (arg1)->offsetx = arg2;
   12436             :   resultobj = SWIG_Py_Void();
   12437           0 :   return resultobj;
   12438           0 : fail:
   12439             :   return NULL;
   12440             : }
   12441             : 
   12442             : 
   12443           1 : SWIGINTERN PyObject *_wrap_styleObj_offsetx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12444             :   PyObject *resultobj = 0;
   12445             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12446           1 :   void *argp1 = 0 ;
   12447             :   int res1 = 0 ;
   12448           1 :   PyObject * obj0 = 0 ;
   12449             :   double result;
   12450             :   
   12451           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_offsetx_get",&obj0)) SWIG_fail;
   12452           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12453           1 :   if (!SWIG_IsOK(res1)) {
   12454           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsetx_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12455             :   }
   12456           1 :   arg1 = (struct styleObj *)(argp1);
   12457           1 :   result = (double) ((arg1)->offsetx);
   12458           1 :   resultobj = SWIG_From_double((double)(result));
   12459           1 :   return resultobj;
   12460           0 : fail:
   12461             :   return NULL;
   12462             : }
   12463             : 
   12464             : 
   12465           0 : SWIGINTERN PyObject *_wrap_styleObj_offsety_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12466             :   PyObject *resultobj = 0;
   12467             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12468             :   double arg2 ;
   12469           0 :   void *argp1 = 0 ;
   12470             :   int res1 = 0 ;
   12471             :   double val2 ;
   12472             :   int ecode2 = 0 ;
   12473           0 :   PyObject * obj0 = 0 ;
   12474           0 :   PyObject * obj1 = 0 ;
   12475             :   
   12476           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_offsety_set",&obj0,&obj1)) SWIG_fail;
   12477           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12478           0 :   if (!SWIG_IsOK(res1)) {
   12479           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsety_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12480             :   }
   12481           0 :   arg1 = (struct styleObj *)(argp1);
   12482           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12483           0 :   if (!SWIG_IsOK(ecode2)) {
   12484           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_offsety_set" "', argument " "2"" of type '" "double""'");
   12485             :   } 
   12486           0 :   arg2 = (double)(val2);
   12487           0 :   if (arg1) (arg1)->offsety = arg2;
   12488             :   resultobj = SWIG_Py_Void();
   12489           0 :   return resultobj;
   12490           0 : fail:
   12491             :   return NULL;
   12492             : }
   12493             : 
   12494             : 
   12495           1 : SWIGINTERN PyObject *_wrap_styleObj_offsety_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12496             :   PyObject *resultobj = 0;
   12497             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12498           1 :   void *argp1 = 0 ;
   12499             :   int res1 = 0 ;
   12500           1 :   PyObject * obj0 = 0 ;
   12501             :   double result;
   12502             :   
   12503           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_offsety_get",&obj0)) SWIG_fail;
   12504           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12505           1 :   if (!SWIG_IsOK(res1)) {
   12506           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsety_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12507             :   }
   12508           1 :   arg1 = (struct styleObj *)(argp1);
   12509           1 :   result = (double) ((arg1)->offsety);
   12510           1 :   resultobj = SWIG_From_double((double)(result));
   12511           1 :   return resultobj;
   12512           0 : fail:
   12513             :   return NULL;
   12514             : }
   12515             : 
   12516             : 
   12517           0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetpixel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12518             :   PyObject *resultobj = 0;
   12519             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12520             :   double arg2 ;
   12521           0 :   void *argp1 = 0 ;
   12522             :   int res1 = 0 ;
   12523             :   double val2 ;
   12524             :   int ecode2 = 0 ;
   12525           0 :   PyObject * obj0 = 0 ;
   12526           0 :   PyObject * obj1 = 0 ;
   12527             :   
   12528           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_polaroffsetpixel_set",&obj0,&obj1)) SWIG_fail;
   12529           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12530           0 :   if (!SWIG_IsOK(res1)) {
   12531           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetpixel_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12532             :   }
   12533           0 :   arg1 = (struct styleObj *)(argp1);
   12534           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12535           0 :   if (!SWIG_IsOK(ecode2)) {
   12536           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_polaroffsetpixel_set" "', argument " "2"" of type '" "double""'");
   12537             :   } 
   12538           0 :   arg2 = (double)(val2);
   12539           0 :   if (arg1) (arg1)->polaroffsetpixel = arg2;
   12540             :   resultobj = SWIG_Py_Void();
   12541           0 :   return resultobj;
   12542           0 : fail:
   12543             :   return NULL;
   12544             : }
   12545             : 
   12546             : 
   12547           0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetpixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12548             :   PyObject *resultobj = 0;
   12549             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12550           0 :   void *argp1 = 0 ;
   12551             :   int res1 = 0 ;
   12552           0 :   PyObject * obj0 = 0 ;
   12553             :   double result;
   12554             :   
   12555           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_polaroffsetpixel_get",&obj0)) SWIG_fail;
   12556           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12557           0 :   if (!SWIG_IsOK(res1)) {
   12558           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetpixel_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12559             :   }
   12560           0 :   arg1 = (struct styleObj *)(argp1);
   12561           0 :   result = (double) ((arg1)->polaroffsetpixel);
   12562           0 :   resultobj = SWIG_From_double((double)(result));
   12563           0 :   return resultobj;
   12564           0 : fail:
   12565             :   return NULL;
   12566             : }
   12567             : 
   12568             : 
   12569           0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetangle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12570             :   PyObject *resultobj = 0;
   12571             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12572             :   double arg2 ;
   12573           0 :   void *argp1 = 0 ;
   12574             :   int res1 = 0 ;
   12575             :   double val2 ;
   12576             :   int ecode2 = 0 ;
   12577           0 :   PyObject * obj0 = 0 ;
   12578           0 :   PyObject * obj1 = 0 ;
   12579             :   
   12580           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_polaroffsetangle_set",&obj0,&obj1)) SWIG_fail;
   12581           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12582           0 :   if (!SWIG_IsOK(res1)) {
   12583           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetangle_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12584             :   }
   12585           0 :   arg1 = (struct styleObj *)(argp1);
   12586           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12587           0 :   if (!SWIG_IsOK(ecode2)) {
   12588           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_polaroffsetangle_set" "', argument " "2"" of type '" "double""'");
   12589             :   } 
   12590           0 :   arg2 = (double)(val2);
   12591           0 :   if (arg1) (arg1)->polaroffsetangle = arg2;
   12592             :   resultobj = SWIG_Py_Void();
   12593           0 :   return resultobj;
   12594           0 : fail:
   12595             :   return NULL;
   12596             : }
   12597             : 
   12598             : 
   12599           0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetangle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12600             :   PyObject *resultobj = 0;
   12601             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12602           0 :   void *argp1 = 0 ;
   12603             :   int res1 = 0 ;
   12604           0 :   PyObject * obj0 = 0 ;
   12605             :   double result;
   12606             :   
   12607           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_polaroffsetangle_get",&obj0)) SWIG_fail;
   12608           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12609           0 :   if (!SWIG_IsOK(res1)) {
   12610           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetangle_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12611             :   }
   12612           0 :   arg1 = (struct styleObj *)(argp1);
   12613           0 :   result = (double) ((arg1)->polaroffsetangle);
   12614           0 :   resultobj = SWIG_From_double((double)(result));
   12615           0 :   return resultobj;
   12616           0 : fail:
   12617             :   return NULL;
   12618             : }
   12619             : 
   12620             : 
   12621           0 : SWIGINTERN PyObject *_wrap_styleObj_angle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12622             :   PyObject *resultobj = 0;
   12623             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12624             :   double arg2 ;
   12625           0 :   void *argp1 = 0 ;
   12626             :   int res1 = 0 ;
   12627             :   double val2 ;
   12628             :   int ecode2 = 0 ;
   12629           0 :   PyObject * obj0 = 0 ;
   12630           0 :   PyObject * obj1 = 0 ;
   12631             :   
   12632           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_angle_set",&obj0,&obj1)) SWIG_fail;
   12633           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12634           0 :   if (!SWIG_IsOK(res1)) {
   12635           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_angle_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12636             :   }
   12637           0 :   arg1 = (struct styleObj *)(argp1);
   12638           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12639           0 :   if (!SWIG_IsOK(ecode2)) {
   12640           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_angle_set" "', argument " "2"" of type '" "double""'");
   12641             :   } 
   12642           0 :   arg2 = (double)(val2);
   12643           0 :   if (arg1) (arg1)->angle = arg2;
   12644             :   resultobj = SWIG_Py_Void();
   12645           0 :   return resultobj;
   12646           0 : fail:
   12647             :   return NULL;
   12648             : }
   12649             : 
   12650             : 
   12651           0 : SWIGINTERN PyObject *_wrap_styleObj_angle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12652             :   PyObject *resultobj = 0;
   12653             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12654           0 :   void *argp1 = 0 ;
   12655             :   int res1 = 0 ;
   12656           0 :   PyObject * obj0 = 0 ;
   12657             :   double result;
   12658             :   
   12659           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_angle_get",&obj0)) SWIG_fail;
   12660           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12661           0 :   if (!SWIG_IsOK(res1)) {
   12662           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_angle_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12663             :   }
   12664           0 :   arg1 = (struct styleObj *)(argp1);
   12665           0 :   result = (double) ((arg1)->angle);
   12666           0 :   resultobj = SWIG_From_double((double)(result));
   12667           0 :   return resultobj;
   12668           0 : fail:
   12669             :   return NULL;
   12670             : }
   12671             : 
   12672             : 
   12673           0 : SWIGINTERN PyObject *_wrap_styleObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12674             :   PyObject *resultobj = 0;
   12675             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12676             :   double arg2 ;
   12677           0 :   void *argp1 = 0 ;
   12678             :   int res1 = 0 ;
   12679             :   double val2 ;
   12680             :   int ecode2 = 0 ;
   12681           0 :   PyObject * obj0 = 0 ;
   12682           0 :   PyObject * obj1 = 0 ;
   12683             :   
   12684           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
   12685           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12686           0 :   if (!SWIG_IsOK(res1)) {
   12687           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minscaledenom_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12688             :   }
   12689           0 :   arg1 = (struct styleObj *)(argp1);
   12690           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12691           0 :   if (!SWIG_IsOK(ecode2)) {
   12692           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
   12693             :   } 
   12694           0 :   arg2 = (double)(val2);
   12695           0 :   if (arg1) (arg1)->minscaledenom = arg2;
   12696             :   resultobj = SWIG_Py_Void();
   12697           0 :   return resultobj;
   12698           0 : fail:
   12699             :   return NULL;
   12700             : }
   12701             : 
   12702             : 
   12703           0 : SWIGINTERN PyObject *_wrap_styleObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12704             :   PyObject *resultobj = 0;
   12705             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12706           0 :   void *argp1 = 0 ;
   12707             :   int res1 = 0 ;
   12708           0 :   PyObject * obj0 = 0 ;
   12709             :   double result;
   12710             :   
   12711           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minscaledenom_get",&obj0)) SWIG_fail;
   12712           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12713           0 :   if (!SWIG_IsOK(res1)) {
   12714           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minscaledenom_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12715             :   }
   12716           0 :   arg1 = (struct styleObj *)(argp1);
   12717           0 :   result = (double) ((arg1)->minscaledenom);
   12718           0 :   resultobj = SWIG_From_double((double)(result));
   12719           0 :   return resultobj;
   12720           0 : fail:
   12721             :   return NULL;
   12722             : }
   12723             : 
   12724             : 
   12725           0 : SWIGINTERN PyObject *_wrap_styleObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12726             :   PyObject *resultobj = 0;
   12727             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12728             :   double arg2 ;
   12729           0 :   void *argp1 = 0 ;
   12730             :   int res1 = 0 ;
   12731             :   double val2 ;
   12732             :   int ecode2 = 0 ;
   12733           0 :   PyObject * obj0 = 0 ;
   12734           0 :   PyObject * obj1 = 0 ;
   12735             :   
   12736           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
   12737           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12738           0 :   if (!SWIG_IsOK(res1)) {
   12739           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxscaledenom_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12740             :   }
   12741           0 :   arg1 = (struct styleObj *)(argp1);
   12742           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   12743           0 :   if (!SWIG_IsOK(ecode2)) {
   12744           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
   12745             :   } 
   12746           0 :   arg2 = (double)(val2);
   12747           0 :   if (arg1) (arg1)->maxscaledenom = arg2;
   12748             :   resultobj = SWIG_Py_Void();
   12749           0 :   return resultobj;
   12750           0 : fail:
   12751             :   return NULL;
   12752             : }
   12753             : 
   12754             : 
   12755           0 : SWIGINTERN PyObject *_wrap_styleObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12756             :   PyObject *resultobj = 0;
   12757             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12758           0 :   void *argp1 = 0 ;
   12759             :   int res1 = 0 ;
   12760           0 :   PyObject * obj0 = 0 ;
   12761             :   double result;
   12762             :   
   12763           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxscaledenom_get",&obj0)) SWIG_fail;
   12764           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12765           0 :   if (!SWIG_IsOK(res1)) {
   12766           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxscaledenom_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12767             :   }
   12768           0 :   arg1 = (struct styleObj *)(argp1);
   12769           0 :   result = (double) ((arg1)->maxscaledenom);
   12770           0 :   resultobj = SWIG_From_double((double)(result));
   12771           0 :   return resultobj;
   12772           0 : fail:
   12773             :   return NULL;
   12774             : }
   12775             : 
   12776             : 
   12777           0 : SWIGINTERN PyObject *_wrap_styleObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12778             :   PyObject *resultobj = 0;
   12779             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12780             :   int arg2 ;
   12781           0 :   void *argp1 = 0 ;
   12782             :   int res1 = 0 ;
   12783             :   int val2 ;
   12784             :   int ecode2 = 0 ;
   12785           0 :   PyObject * obj0 = 0 ;
   12786           0 :   PyObject * obj1 = 0 ;
   12787             :   
   12788           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
   12789           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12790           0 :   if (!SWIG_IsOK(res1)) {
   12791           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_sizeunits_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12792             :   }
   12793           0 :   arg1 = (struct styleObj *)(argp1);
   12794           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   12795           0 :   if (!SWIG_IsOK(ecode2)) {
   12796           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
   12797             :   } 
   12798             :   arg2 = (int)(val2);
   12799           0 :   if (arg1) (arg1)->sizeunits = arg2;
   12800             :   resultobj = SWIG_Py_Void();
   12801           0 :   return resultobj;
   12802           0 : fail:
   12803             :   return NULL;
   12804             : }
   12805             : 
   12806             : 
   12807           0 : SWIGINTERN PyObject *_wrap_styleObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12808             :   PyObject *resultobj = 0;
   12809             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12810           0 :   void *argp1 = 0 ;
   12811             :   int res1 = 0 ;
   12812           0 :   PyObject * obj0 = 0 ;
   12813             :   int result;
   12814             :   
   12815           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_sizeunits_get",&obj0)) SWIG_fail;
   12816           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12817           0 :   if (!SWIG_IsOK(res1)) {
   12818           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_sizeunits_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12819             :   }
   12820           0 :   arg1 = (struct styleObj *)(argp1);
   12821           0 :   result = (int) ((arg1)->sizeunits);
   12822             :   resultobj = SWIG_From_int((int)(result));
   12823           0 :   return resultobj;
   12824           0 : fail:
   12825             :   return NULL;
   12826             : }
   12827             : 
   12828             : 
   12829           1 : SWIGINTERN PyObject *_wrap_new_styleObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12830             :   PyObject *resultobj = 0;
   12831             :   classObj *arg1 = (classObj *) NULL ;
   12832           1 :   void *argp1 = 0 ;
   12833             :   int res1 = 0 ;
   12834           1 :   PyObject * obj0 = 0 ;
   12835             :   struct styleObj *result = 0 ;
   12836             :   
   12837           1 :   if (!PyArg_ParseTuple(args,(char *)"|O:new_styleObj",&obj0)) SWIG_fail;
   12838           1 :   if (obj0) {
   12839           1 :     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   12840           1 :     if (!SWIG_IsOK(res1)) {
   12841           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_styleObj" "', argument " "1"" of type '" "classObj *""'"); 
   12842             :     }
   12843           1 :     arg1 = (classObj *)(argp1);
   12844             :   }
   12845             :   {
   12846           1 :     result = (struct styleObj *)new_styleObj(arg1); {
   12847           1 :       errorObj *ms_error = msGetErrorObj();
   12848             :       
   12849           1 :       switch(ms_error->code) {
   12850             :       case MS_NOERR:
   12851             :         break;
   12852           0 :       case MS_NOTFOUND:
   12853           0 :         msResetErrorList();
   12854           0 :         break;
   12855             :       case -1:
   12856             :         break;
   12857           0 :       case MS_IOERR:
   12858           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   12859           0 :           _raise_ms_exception();
   12860           0 :           msResetErrorList();
   12861           0 :           return NULL;
   12862             :         }
   12863             :       default:
   12864           0 :         _raise_ms_exception();
   12865           0 :         msResetErrorList();
   12866           0 :         return NULL;
   12867             :       }
   12868             :       
   12869             :     }
   12870             :   }
   12871           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_NEW |  0 );
   12872           1 :   return resultobj;
   12873           0 : fail:
   12874             :   return NULL;
   12875             : }
   12876             : 
   12877             : 
   12878           1 : SWIGINTERN PyObject *_wrap_delete_styleObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12879             :   PyObject *resultobj = 0;
   12880             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12881           1 :   void *argp1 = 0 ;
   12882             :   int res1 = 0 ;
   12883           1 :   PyObject * obj0 = 0 ;
   12884             :   
   12885           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_styleObj",&obj0)) SWIG_fail;
   12886           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, SWIG_POINTER_DISOWN |  0 );
   12887           1 :   if (!SWIG_IsOK(res1)) {
   12888           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_styleObj" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12889             :   }
   12890           1 :   arg1 = (struct styleObj *)(argp1);
   12891             :   {
   12892           1 :     delete_styleObj(arg1); {
   12893           1 :       errorObj *ms_error = msGetErrorObj();
   12894             :       
   12895           1 :       switch(ms_error->code) {
   12896             :       case MS_NOERR:
   12897             :         break;
   12898           0 :       case MS_NOTFOUND:
   12899           0 :         msResetErrorList();
   12900           0 :         break;
   12901             :       case -1:
   12902             :         break;
   12903           0 :       case MS_IOERR:
   12904           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   12905           0 :           _raise_ms_exception();
   12906           0 :           msResetErrorList();
   12907           0 :           return NULL;
   12908             :         }
   12909             :       default:
   12910           0 :         _raise_ms_exception();
   12911           0 :         msResetErrorList();
   12912           0 :         return NULL;
   12913             :       }
   12914             :       
   12915             :     }
   12916             :   }
   12917             :   resultobj = SWIG_Py_Void();
   12918           1 :   return resultobj;
   12919           0 : fail:
   12920             :   return NULL;
   12921             : }
   12922             : 
   12923             : 
   12924           1 : SWIGINTERN PyObject *_wrap_styleObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12925             :   PyObject *resultobj = 0;
   12926             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12927             :   char *arg2 = (char *) 0 ;
   12928           1 :   void *argp1 = 0 ;
   12929             :   int res1 = 0 ;
   12930             :   int res2 ;
   12931           1 :   char *buf2 = 0 ;
   12932           1 :   int alloc2 = 0 ;
   12933           1 :   PyObject * obj0 = 0 ;
   12934           1 :   PyObject * obj1 = 0 ;
   12935             :   int result;
   12936             :   
   12937           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   12938           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12939           1 :   if (!SWIG_IsOK(res1)) {
   12940           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_updateFromString" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12941             :   }
   12942           1 :   arg1 = (struct styleObj *)(argp1);
   12943           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   12944           1 :   if (!SWIG_IsOK(res2)) {
   12945           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   12946             :   }
   12947           1 :   arg2 = (char *)(buf2);
   12948             :   {
   12949             :     result = (int)styleObj_updateFromString(arg1,arg2); {
   12950           1 :       errorObj *ms_error = msGetErrorObj();
   12951             :       
   12952           1 :       switch(ms_error->code) {
   12953             :       case MS_NOERR:
   12954             :         break;
   12955           0 :       case MS_NOTFOUND:
   12956           0 :         msResetErrorList();
   12957           0 :         break;
   12958             :       case -1:
   12959             :         break;
   12960           0 :       case MS_IOERR:
   12961           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   12962           0 :           _raise_ms_exception();
   12963           0 :           msResetErrorList();
   12964           0 :           return NULL;
   12965             :         }
   12966             :       default:
   12967           0 :         _raise_ms_exception();
   12968           0 :         msResetErrorList();
   12969           0 :         return NULL;
   12970             :       }
   12971             :       
   12972             :     }
   12973             :   }
   12974             :   resultobj = SWIG_From_int((int)(result));
   12975           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   12976             :   return resultobj;
   12977           0 : fail:
   12978           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   12979             :   return NULL;
   12980             : }
   12981             : 
   12982             : 
   12983           1 : SWIGINTERN PyObject *_wrap_styleObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   12984             :   PyObject *resultobj = 0;
   12985             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   12986           1 :   void *argp1 = 0 ;
   12987             :   int res1 = 0 ;
   12988           1 :   PyObject * obj0 = 0 ;
   12989             :   char *result = 0 ;
   12990             :   
   12991           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_convertToString",&obj0)) SWIG_fail;
   12992           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   12993           1 :   if (!SWIG_IsOK(res1)) {
   12994           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_convertToString" "', argument " "1"" of type '" "struct styleObj *""'"); 
   12995             :   }
   12996           1 :   arg1 = (struct styleObj *)(argp1);
   12997             :   {
   12998             :     result = (char *)styleObj_convertToString(arg1); {
   12999           1 :       errorObj *ms_error = msGetErrorObj();
   13000             :       
   13001           1 :       switch(ms_error->code) {
   13002             :       case MS_NOERR:
   13003             :         break;
   13004           0 :       case MS_NOTFOUND:
   13005           0 :         msResetErrorList();
   13006           0 :         break;
   13007             :       case -1:
   13008             :         break;
   13009           0 :       case MS_IOERR:
   13010           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13011           0 :           _raise_ms_exception();
   13012           0 :           msResetErrorList();
   13013           0 :           return NULL;
   13014             :         }
   13015             :       default:
   13016           0 :         _raise_ms_exception();
   13017           0 :         msResetErrorList();
   13018           0 :         return NULL;
   13019             :       }
   13020             :       
   13021             :     }
   13022             :   }
   13023           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   13024           1 :   free((char*)result);
   13025           1 :   return resultobj;
   13026           0 : fail:
   13027             :   return NULL;
   13028             : }
   13029             : 
   13030             : 
   13031           1 : SWIGINTERN PyObject *_wrap_styleObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13032             :   PyObject *resultobj = 0;
   13033             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13034           1 :   void *argp1 = 0 ;
   13035             :   int res1 = 0 ;
   13036           1 :   PyObject * obj0 = 0 ;
   13037             :   styleObj *result = 0 ;
   13038             :   
   13039           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_clone",&obj0)) SWIG_fail;
   13040           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13041           1 :   if (!SWIG_IsOK(res1)) {
   13042           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_clone" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13043             :   }
   13044           1 :   arg1 = (struct styleObj *)(argp1);
   13045             :   {
   13046           1 :     result = (styleObj *)styleObj_clone(arg1); {
   13047           1 :       errorObj *ms_error = msGetErrorObj();
   13048             :       
   13049           1 :       switch(ms_error->code) {
   13050             :       case MS_NOERR:
   13051             :         break;
   13052           0 :       case MS_NOTFOUND:
   13053           0 :         msResetErrorList();
   13054           0 :         break;
   13055             :       case -1:
   13056             :         break;
   13057           0 :       case MS_IOERR:
   13058           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13059           0 :           _raise_ms_exception();
   13060           0 :           msResetErrorList();
   13061           0 :           return NULL;
   13062             :         }
   13063             :       default:
   13064           0 :         _raise_ms_exception();
   13065           0 :         msResetErrorList();
   13066           0 :         return NULL;
   13067             :       }
   13068             :       
   13069             :     }
   13070             :   }
   13071           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN |  0 );
   13072           1 :   return resultobj;
   13073           0 : fail:
   13074             :   return NULL;
   13075             : }
   13076             : 
   13077             : 
   13078           1 : SWIGINTERN PyObject *_wrap_styleObj_setSymbolByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13079             :   PyObject *resultobj = 0;
   13080             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13081             :   mapObj *arg2 = (mapObj *) 0 ;
   13082             :   char *arg3 = (char *) 0 ;
   13083           1 :   void *argp1 = 0 ;
   13084             :   int res1 = 0 ;
   13085           1 :   void *argp2 = 0 ;
   13086             :   int res2 = 0 ;
   13087             :   int res3 ;
   13088           1 :   char *buf3 = 0 ;
   13089           1 :   int alloc3 = 0 ;
   13090           1 :   PyObject * obj0 = 0 ;
   13091           1 :   PyObject * obj1 = 0 ;
   13092           1 :   PyObject * obj2 = 0 ;
   13093             :   int result;
   13094             :   
   13095           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:styleObj_setSymbolByName",&obj0,&obj1,&obj2)) SWIG_fail;
   13096           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13097           1 :   if (!SWIG_IsOK(res1)) {
   13098           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_setSymbolByName" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13099             :   }
   13100           1 :   arg1 = (struct styleObj *)(argp1);
   13101           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   13102           1 :   if (!SWIG_IsOK(res2)) {
   13103           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_setSymbolByName" "', argument " "2"" of type '" "mapObj *""'"); 
   13104             :   }
   13105           1 :   arg2 = (mapObj *)(argp2);
   13106           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   13107           1 :   if (!SWIG_IsOK(res3)) {
   13108           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "styleObj_setSymbolByName" "', argument " "3"" of type '" "char *""'");
   13109             :   }
   13110           1 :   arg3 = (char *)(buf3);
   13111             :   {
   13112           1 :     result = (int)styleObj_setSymbolByName(arg1,arg2,arg3); {
   13113           1 :       errorObj *ms_error = msGetErrorObj();
   13114             :       
   13115           1 :       switch(ms_error->code) {
   13116             :       case MS_NOERR:
   13117             :         break;
   13118           0 :       case MS_NOTFOUND:
   13119           0 :         msResetErrorList();
   13120           0 :         break;
   13121             :       case -1:
   13122             :         break;
   13123           0 :       case MS_IOERR:
   13124           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13125           0 :           _raise_ms_exception();
   13126           0 :           msResetErrorList();
   13127           0 :           return NULL;
   13128             :         }
   13129             :       default:
   13130           0 :         _raise_ms_exception();
   13131           0 :         msResetErrorList();
   13132           0 :         return NULL;
   13133             :       }
   13134             :       
   13135             :     }
   13136             :   }
   13137             :   resultobj = SWIG_From_int((int)(result));
   13138           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   13139             :   return resultobj;
   13140           0 : fail:
   13141           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   13142             :   return NULL;
   13143             : }
   13144             : 
   13145             : 
   13146           0 : SWIGINTERN PyObject *_wrap_styleObj_removeBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13147             :   PyObject *resultobj = 0;
   13148             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13149             :   int arg2 ;
   13150           0 :   void *argp1 = 0 ;
   13151             :   int res1 = 0 ;
   13152             :   int val2 ;
   13153             :   int ecode2 = 0 ;
   13154           0 :   PyObject * obj0 = 0 ;
   13155           0 :   PyObject * obj1 = 0 ;
   13156             :   int result;
   13157             :   
   13158           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_removeBinding",&obj0,&obj1)) SWIG_fail;
   13159           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13160           0 :   if (!SWIG_IsOK(res1)) {
   13161           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_removeBinding" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13162             :   }
   13163           0 :   arg1 = (struct styleObj *)(argp1);
   13164           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   13165           0 :   if (!SWIG_IsOK(ecode2)) {
   13166           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_removeBinding" "', argument " "2"" of type '" "int""'");
   13167             :   } 
   13168             :   arg2 = (int)(val2);
   13169             :   {
   13170             :     result = (int)styleObj_removeBinding(arg1,arg2); {
   13171           0 :       errorObj *ms_error = msGetErrorObj();
   13172             :       
   13173           0 :       switch(ms_error->code) {
   13174             :       case MS_NOERR:
   13175             :         break;
   13176           0 :       case MS_NOTFOUND:
   13177           0 :         msResetErrorList();
   13178           0 :         break;
   13179             :       case -1:
   13180             :         break;
   13181           0 :       case MS_IOERR:
   13182           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13183           0 :           _raise_ms_exception();
   13184           0 :           msResetErrorList();
   13185           0 :           return NULL;
   13186             :         }
   13187             :       default:
   13188           0 :         _raise_ms_exception();
   13189           0 :         msResetErrorList();
   13190           0 :         return NULL;
   13191             :       }
   13192             :       
   13193             :     }
   13194             :   }
   13195             :   resultobj = SWIG_From_int((int)(result));
   13196           0 :   return resultobj;
   13197           0 : fail:
   13198             :   return NULL;
   13199             : }
   13200             : 
   13201             : 
   13202           1 : SWIGINTERN PyObject *_wrap_styleObj_setBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13203             :   PyObject *resultobj = 0;
   13204             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13205             :   int arg2 ;
   13206             :   char *arg3 = (char *) 0 ;
   13207           1 :   void *argp1 = 0 ;
   13208             :   int res1 = 0 ;
   13209             :   int val2 ;
   13210             :   int ecode2 = 0 ;
   13211             :   int res3 ;
   13212           1 :   char *buf3 = 0 ;
   13213           1 :   int alloc3 = 0 ;
   13214           1 :   PyObject * obj0 = 0 ;
   13215           1 :   PyObject * obj1 = 0 ;
   13216           1 :   PyObject * obj2 = 0 ;
   13217             :   int result;
   13218             :   
   13219           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:styleObj_setBinding",&obj0,&obj1,&obj2)) SWIG_fail;
   13220           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13221           1 :   if (!SWIG_IsOK(res1)) {
   13222           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_setBinding" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13223             :   }
   13224           1 :   arg1 = (struct styleObj *)(argp1);
   13225           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   13226           1 :   if (!SWIG_IsOK(ecode2)) {
   13227           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_setBinding" "', argument " "2"" of type '" "int""'");
   13228             :   } 
   13229             :   arg2 = (int)(val2);
   13230           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   13231           1 :   if (!SWIG_IsOK(res3)) {
   13232           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "styleObj_setBinding" "', argument " "3"" of type '" "char *""'");
   13233             :   }
   13234           1 :   arg3 = (char *)(buf3);
   13235             :   {
   13236           1 :     result = (int)styleObj_setBinding(arg1,arg2,arg3); {
   13237           1 :       errorObj *ms_error = msGetErrorObj();
   13238             :       
   13239           1 :       switch(ms_error->code) {
   13240             :       case MS_NOERR:
   13241             :         break;
   13242           0 :       case MS_NOTFOUND:
   13243           0 :         msResetErrorList();
   13244           0 :         break;
   13245             :       case -1:
   13246             :         break;
   13247           0 :       case MS_IOERR:
   13248           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13249           0 :           _raise_ms_exception();
   13250           0 :           msResetErrorList();
   13251           0 :           return NULL;
   13252             :         }
   13253             :       default:
   13254           0 :         _raise_ms_exception();
   13255           0 :         msResetErrorList();
   13256           0 :         return NULL;
   13257             :       }
   13258             :       
   13259             :     }
   13260             :   }
   13261             :   resultobj = SWIG_From_int((int)(result));
   13262           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   13263             :   return resultobj;
   13264           0 : fail:
   13265           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   13266             :   return NULL;
   13267             : }
   13268             : 
   13269             : 
   13270           1 : SWIGINTERN PyObject *_wrap_styleObj_getBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13271             :   PyObject *resultobj = 0;
   13272             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13273             :   int arg2 ;
   13274           1 :   void *argp1 = 0 ;
   13275             :   int res1 = 0 ;
   13276             :   int val2 ;
   13277             :   int ecode2 = 0 ;
   13278           1 :   PyObject * obj0 = 0 ;
   13279           1 :   PyObject * obj1 = 0 ;
   13280             :   char *result = 0 ;
   13281             :   
   13282           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_getBinding",&obj0,&obj1)) SWIG_fail;
   13283           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13284           1 :   if (!SWIG_IsOK(res1)) {
   13285           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_getBinding" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13286             :   }
   13287           1 :   arg1 = (struct styleObj *)(argp1);
   13288           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   13289           1 :   if (!SWIG_IsOK(ecode2)) {
   13290           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_getBinding" "', argument " "2"" of type '" "int""'");
   13291             :   } 
   13292             :   arg2 = (int)(val2);
   13293             :   {
   13294             :     result = (char *)styleObj_getBinding(arg1,arg2); {
   13295           1 :       errorObj *ms_error = msGetErrorObj();
   13296             :       
   13297           1 :       switch(ms_error->code) {
   13298             :       case MS_NOERR:
   13299             :         break;
   13300           0 :       case MS_NOTFOUND:
   13301           0 :         msResetErrorList();
   13302           0 :         break;
   13303             :       case -1:
   13304             :         break;
   13305           0 :       case MS_IOERR:
   13306           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13307           0 :           _raise_ms_exception();
   13308           0 :           msResetErrorList();
   13309           0 :           return NULL;
   13310             :         }
   13311             :       default:
   13312           0 :         _raise_ms_exception();
   13313           0 :         msResetErrorList();
   13314           0 :         return NULL;
   13315             :       }
   13316             :       
   13317             :     }
   13318             :   }
   13319           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   13320           1 :   return resultobj;
   13321           0 : fail:
   13322             :   return NULL;
   13323             : }
   13324             : 
   13325             : 
   13326           0 : SWIGINTERN PyObject *_wrap_styleObj_getGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13327             :   PyObject *resultobj = 0;
   13328             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13329           0 :   void *argp1 = 0 ;
   13330             :   int res1 = 0 ;
   13331           0 :   PyObject * obj0 = 0 ;
   13332             :   char *result = 0 ;
   13333             :   
   13334           0 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_getGeomTransform",&obj0)) SWIG_fail;
   13335           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13336           0 :   if (!SWIG_IsOK(res1)) {
   13337           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_getGeomTransform" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13338             :   }
   13339           0 :   arg1 = (struct styleObj *)(argp1);
   13340             :   {
   13341           0 :     result = (char *)styleObj_getGeomTransform(arg1); {
   13342           0 :       errorObj *ms_error = msGetErrorObj();
   13343             :       
   13344           0 :       switch(ms_error->code) {
   13345             :       case MS_NOERR:
   13346             :         break;
   13347           0 :       case MS_NOTFOUND:
   13348           0 :         msResetErrorList();
   13349           0 :         break;
   13350             :       case -1:
   13351             :         break;
   13352           0 :       case MS_IOERR:
   13353           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13354           0 :           _raise_ms_exception();
   13355           0 :           msResetErrorList();
   13356           0 :           return NULL;
   13357             :         }
   13358             :       default:
   13359           0 :         _raise_ms_exception();
   13360           0 :         msResetErrorList();
   13361           0 :         return NULL;
   13362             :       }
   13363             :       
   13364             :     }
   13365             :   }
   13366           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   13367           0 :   return resultobj;
   13368           0 : fail:
   13369             :   return NULL;
   13370             : }
   13371             : 
   13372             : 
   13373           0 : SWIGINTERN PyObject *_wrap_styleObj_setGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13374             :   PyObject *resultobj = 0;
   13375             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13376             :   char *arg2 = (char *) 0 ;
   13377           0 :   void *argp1 = 0 ;
   13378             :   int res1 = 0 ;
   13379             :   int res2 ;
   13380           0 :   char *buf2 = 0 ;
   13381           0 :   int alloc2 = 0 ;
   13382           0 :   PyObject * obj0 = 0 ;
   13383           0 :   PyObject * obj1 = 0 ;
   13384             :   
   13385           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_setGeomTransform",&obj0,&obj1)) SWIG_fail;
   13386           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13387           0 :   if (!SWIG_IsOK(res1)) {
   13388           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_setGeomTransform" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13389             :   }
   13390           0 :   arg1 = (struct styleObj *)(argp1);
   13391           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   13392           0 :   if (!SWIG_IsOK(res2)) {
   13393           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_setGeomTransform" "', argument " "2"" of type '" "char *""'");
   13394             :   }
   13395           0 :   arg2 = (char *)(buf2);
   13396             :   {
   13397             :     styleObj_setGeomTransform(arg1,arg2); {
   13398           0 :       errorObj *ms_error = msGetErrorObj();
   13399             :       
   13400           0 :       switch(ms_error->code) {
   13401             :       case MS_NOERR:
   13402             :         break;
   13403           0 :       case MS_NOTFOUND:
   13404           0 :         msResetErrorList();
   13405           0 :         break;
   13406             :       case -1:
   13407             :         break;
   13408           0 :       case MS_IOERR:
   13409           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13410           0 :           _raise_ms_exception();
   13411           0 :           msResetErrorList();
   13412           0 :           return NULL;
   13413             :         }
   13414             :       default:
   13415           0 :         _raise_ms_exception();
   13416           0 :         msResetErrorList();
   13417           0 :         return NULL;
   13418             :       }
   13419             :       
   13420             :     }
   13421             :   }
   13422             :   resultobj = SWIG_Py_Void();
   13423           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   13424             :   return resultobj;
   13425           0 : fail:
   13426           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   13427             :   return NULL;
   13428             : }
   13429             : 
   13430             : 
   13431           1 : SWIGINTERN PyObject *_wrap_styleObj_pattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13432             :   PyObject *resultobj = 0;
   13433             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13434             :   int arg2 ;
   13435             :   double *arg3 = (double *) 0 ;
   13436           1 :   void *argp1 = 0 ;
   13437             :   int res1 = 0 ;
   13438           1 :   PyObject * obj0 = 0 ;
   13439           1 :   PyObject * obj1 = 0 ;
   13440             :   
   13441           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_pattern_set",&obj0,&obj1)) SWIG_fail;
   13442           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13443           1 :   if (!SWIG_IsOK(res1)) {
   13444           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_pattern_set" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13445             :   }
   13446           1 :   arg1 = (struct styleObj *)(argp1);
   13447             :   {
   13448             :     int i;
   13449             :     /* %typemap(in,numinputs=1) (int nListSize, double* pListValues)*/
   13450             :     /* check if is List */
   13451           1 :     if ( !PySequence_Check(obj1) ) {
   13452           0 :       PyErr_SetString(PyExc_TypeError, "not a sequence");
   13453             :       SWIG_fail;
   13454             :     }
   13455           1 :     arg2 = (int) PySequence_Size(obj1);
   13456           1 :     arg3 = (double*) malloc(arg2*sizeof(double));
   13457           1 :     for( i = 0; i<arg2; i++ ) {
   13458           1 :       PyObject *o = PySequence_GetItem(obj1,i);
   13459           1 :       if ( !PyArg_Parse(o,"d",&arg3[i]) ) {
   13460           0 :         PyErr_SetString(PyExc_TypeError, "not a number");
   13461           0 :         Py_DECREF(o);
   13462             :         SWIG_fail;
   13463             :       }
   13464           1 :       Py_DECREF(o);
   13465             :     }
   13466             :   }
   13467             :   {
   13468           1 :     styleObj_pattern_set(arg1,arg2,arg3); {
   13469           1 :       errorObj *ms_error = msGetErrorObj();
   13470             :       
   13471           1 :       switch(ms_error->code) {
   13472             :       case MS_NOERR:
   13473             :         break;
   13474           0 :       case MS_NOTFOUND:
   13475           0 :         msResetErrorList();
   13476           0 :         break;
   13477             :       case -1:
   13478             :         break;
   13479           0 :       case MS_IOERR:
   13480           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13481           0 :           _raise_ms_exception();
   13482           0 :           msResetErrorList();
   13483           0 :           return NULL;
   13484             :         }
   13485             :       default:
   13486           1 :         _raise_ms_exception();
   13487           1 :         msResetErrorList();
   13488           1 :         return NULL;
   13489             :       }
   13490             :       
   13491             :     }
   13492             :   }
   13493             :   resultobj = SWIG_Py_Void();
   13494             :   {
   13495             :     /* %typemap(freearg) (int nListSize, double* pListValues) */
   13496           1 :     if (arg3) {
   13497           1 :       free((void*) arg3);
   13498             :     }
   13499             :   }
   13500             :   return resultobj;
   13501           0 : fail:
   13502             :   {
   13503             :     /* %typemap(freearg) (int nListSize, double* pListValues) */
   13504           0 :     if (arg3) {
   13505           0 :       free((void*) arg3);
   13506             :     }
   13507             :   }
   13508             :   return NULL;
   13509             : }
   13510             : 
   13511             : 
   13512           1 : SWIGINTERN PyObject *_wrap_styleObj_pattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13513             :   PyObject *resultobj = 0;
   13514             :   struct styleObj *arg1 = (struct styleObj *) 0 ;
   13515             :   double **arg2 = (double **) 0 ;
   13516             :   int *arg3 = (int *) 0 ;
   13517           1 :   void *argp1 = 0 ;
   13518             :   int res1 = 0 ;
   13519             :   double *argout2 ;
   13520             :   int nListSize2 ;
   13521           1 :   PyObject * obj0 = 0 ;
   13522             :   
   13523             :   {
   13524             :     /* %typemap(python,in,numinputs=0) (double *val, int*hasval) */
   13525             :     arg2 = &argout2;
   13526             :     arg3 = &nListSize2;
   13527             :   }
   13528           1 :   if (!PyArg_ParseTuple(args,(char *)"O:styleObj_pattern_get",&obj0)) SWIG_fail;
   13529           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 |  0 );
   13530           1 :   if (!SWIG_IsOK(res1)) {
   13531           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_pattern_get" "', argument " "1"" of type '" "struct styleObj *""'"); 
   13532             :   }
   13533           1 :   arg1 = (struct styleObj *)(argp1);
   13534             :   {
   13535           1 :     styleObj_pattern_get(arg1,arg2,arg3); {
   13536           1 :       errorObj *ms_error = msGetErrorObj();
   13537             :       
   13538           1 :       switch(ms_error->code) {
   13539             :       case MS_NOERR:
   13540             :         break;
   13541           0 :       case MS_NOTFOUND:
   13542           0 :         msResetErrorList();
   13543           0 :         break;
   13544             :       case -1:
   13545             :         break;
   13546           0 :       case MS_IOERR:
   13547           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13548           0 :           _raise_ms_exception();
   13549           0 :           msResetErrorList();
   13550           0 :           return NULL;
   13551             :         }
   13552             :       default:
   13553           0 :         _raise_ms_exception();
   13554           0 :         msResetErrorList();
   13555           0 :         return NULL;
   13556             :       }
   13557             :       
   13558             :     }
   13559             :   }
   13560             :   resultobj = SWIG_Py_Void();
   13561             :   {
   13562             :     /* %typemap(argout) (double* argout, int* pnListSize)  */
   13563             :     PyObject *r;
   13564           1 :     r = CreateTupleFromDoubleArray(*arg2, *arg3);
   13565           1 :     free(*arg2);
   13566           1 :     resultobj = t_output_helper(resultobj,r);
   13567             :   }
   13568           1 :   return resultobj;
   13569           0 : fail:
   13570             :   return NULL;
   13571             : }
   13572             : 
   13573             : 
   13574           1 : SWIGINTERN PyObject *styleObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13575             :   PyObject *obj;
   13576           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   13577           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_styleObj, SWIG_NewClientData(obj));
   13578           1 :   return SWIG_Py_Void();
   13579             : }
   13580             : 
   13581           0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_maxdistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13582             :   PyObject *resultobj = 0;
   13583             :   labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
   13584             :   int arg2 ;
   13585           0 :   void *argp1 = 0 ;
   13586             :   int res1 = 0 ;
   13587             :   int val2 ;
   13588             :   int ecode2 = 0 ;
   13589           0 :   PyObject * obj0 = 0 ;
   13590           0 :   PyObject * obj1 = 0 ;
   13591             :   
   13592           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelLeaderObj_maxdistance_set",&obj0,&obj1)) SWIG_fail;
   13593           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   13594           0 :   if (!SWIG_IsOK(res1)) {
   13595           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_maxdistance_set" "', argument " "1"" of type '" "labelLeaderObj *""'"); 
   13596             :   }
   13597           0 :   arg1 = (labelLeaderObj *)(argp1);
   13598           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   13599           0 :   if (!SWIG_IsOK(ecode2)) {
   13600           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelLeaderObj_maxdistance_set" "', argument " "2"" of type '" "int""'");
   13601             :   } 
   13602             :   arg2 = (int)(val2);
   13603           0 :   if (arg1) (arg1)->maxdistance = arg2;
   13604             :   resultobj = SWIG_Py_Void();
   13605           0 :   return resultobj;
   13606           0 : fail:
   13607             :   return NULL;
   13608             : }
   13609             : 
   13610             : 
   13611           0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_maxdistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13612             :   PyObject *resultobj = 0;
   13613             :   labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
   13614           0 :   void *argp1 = 0 ;
   13615             :   int res1 = 0 ;
   13616           0 :   PyObject * obj0 = 0 ;
   13617             :   int result;
   13618             :   
   13619           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelLeaderObj_maxdistance_get",&obj0)) SWIG_fail;
   13620           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   13621           0 :   if (!SWIG_IsOK(res1)) {
   13622           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_maxdistance_get" "', argument " "1"" of type '" "labelLeaderObj *""'"); 
   13623             :   }
   13624           0 :   arg1 = (labelLeaderObj *)(argp1);
   13625           0 :   result = (int) ((arg1)->maxdistance);
   13626             :   resultobj = SWIG_From_int((int)(result));
   13627           0 :   return resultobj;
   13628           0 : fail:
   13629             :   return NULL;
   13630             : }
   13631             : 
   13632             : 
   13633           0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_gridstep_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13634             :   PyObject *resultobj = 0;
   13635             :   labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
   13636             :   int arg2 ;
   13637           0 :   void *argp1 = 0 ;
   13638             :   int res1 = 0 ;
   13639             :   int val2 ;
   13640             :   int ecode2 = 0 ;
   13641           0 :   PyObject * obj0 = 0 ;
   13642           0 :   PyObject * obj1 = 0 ;
   13643             :   
   13644           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelLeaderObj_gridstep_set",&obj0,&obj1)) SWIG_fail;
   13645           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   13646           0 :   if (!SWIG_IsOK(res1)) {
   13647           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_gridstep_set" "', argument " "1"" of type '" "labelLeaderObj *""'"); 
   13648             :   }
   13649           0 :   arg1 = (labelLeaderObj *)(argp1);
   13650           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   13651           0 :   if (!SWIG_IsOK(ecode2)) {
   13652           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelLeaderObj_gridstep_set" "', argument " "2"" of type '" "int""'");
   13653             :   } 
   13654             :   arg2 = (int)(val2);
   13655           0 :   if (arg1) (arg1)->gridstep = arg2;
   13656             :   resultobj = SWIG_Py_Void();
   13657           0 :   return resultobj;
   13658           0 : fail:
   13659             :   return NULL;
   13660             : }
   13661             : 
   13662             : 
   13663           0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_gridstep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13664             :   PyObject *resultobj = 0;
   13665             :   labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
   13666           0 :   void *argp1 = 0 ;
   13667             :   int res1 = 0 ;
   13668           0 :   PyObject * obj0 = 0 ;
   13669             :   int result;
   13670             :   
   13671           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelLeaderObj_gridstep_get",&obj0)) SWIG_fail;
   13672           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   13673           0 :   if (!SWIG_IsOK(res1)) {
   13674           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_gridstep_get" "', argument " "1"" of type '" "labelLeaderObj *""'"); 
   13675             :   }
   13676           0 :   arg1 = (labelLeaderObj *)(argp1);
   13677           0 :   result = (int) ((arg1)->gridstep);
   13678             :   resultobj = SWIG_From_int((int)(result));
   13679           0 :   return resultobj;
   13680           0 : fail:
   13681             :   return NULL;
   13682             : }
   13683             : 
   13684             : 
   13685           0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_numstyles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13686             :   PyObject *resultobj = 0;
   13687             :   labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
   13688           0 :   void *argp1 = 0 ;
   13689             :   int res1 = 0 ;
   13690           0 :   PyObject * obj0 = 0 ;
   13691             :   int result;
   13692             :   
   13693           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelLeaderObj_numstyles_get",&obj0)) SWIG_fail;
   13694           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   13695           0 :   if (!SWIG_IsOK(res1)) {
   13696           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_numstyles_get" "', argument " "1"" of type '" "labelLeaderObj *""'"); 
   13697             :   }
   13698           0 :   arg1 = (labelLeaderObj *)(argp1);
   13699           0 :   result = (int) ((arg1)->numstyles);
   13700             :   resultobj = SWIG_From_int((int)(result));
   13701           0 :   return resultobj;
   13702           0 : fail:
   13703             :   return NULL;
   13704             : }
   13705             : 
   13706             : 
   13707           0 : SWIGINTERN PyObject *_wrap_new_labelLeaderObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13708             :   PyObject *resultobj = 0;
   13709             :   labelLeaderObj *result = 0 ;
   13710             :   
   13711           0 :   if (!PyArg_ParseTuple(args,(char *)":new_labelLeaderObj")) SWIG_fail;
   13712             :   {
   13713           0 :     result = (labelLeaderObj *)calloc(1, sizeof(labelLeaderObj)); {
   13714           0 :       errorObj *ms_error = msGetErrorObj();
   13715             :       
   13716           0 :       switch(ms_error->code) {
   13717             :       case MS_NOERR:
   13718             :         break;
   13719           0 :       case MS_NOTFOUND:
   13720           0 :         msResetErrorList();
   13721           0 :         break;
   13722             :       case -1:
   13723             :         break;
   13724           0 :       case MS_IOERR:
   13725           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13726           0 :           _raise_ms_exception();
   13727           0 :           msResetErrorList();
   13728           0 :           return NULL;
   13729             :         }
   13730             :       default:
   13731           0 :         _raise_ms_exception();
   13732           0 :         msResetErrorList();
   13733           0 :         return NULL;
   13734             :       }
   13735             :       
   13736             :     }
   13737             :   }
   13738           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelLeaderObj, SWIG_POINTER_NEW |  0 );
   13739           0 :   return resultobj;
   13740           0 : fail:
   13741             :   return NULL;
   13742             : }
   13743             : 
   13744             : 
   13745           0 : SWIGINTERN PyObject *_wrap_delete_labelLeaderObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13746             :   PyObject *resultobj = 0;
   13747             :   labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
   13748           0 :   void *argp1 = 0 ;
   13749             :   int res1 = 0 ;
   13750           0 :   PyObject * obj0 = 0 ;
   13751             :   
   13752           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_labelLeaderObj",&obj0)) SWIG_fail;
   13753           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, SWIG_POINTER_DISOWN |  0 );
   13754           0 :   if (!SWIG_IsOK(res1)) {
   13755           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelLeaderObj" "', argument " "1"" of type '" "labelLeaderObj *""'"); 
   13756             :   }
   13757           0 :   arg1 = (labelLeaderObj *)(argp1);
   13758             :   {
   13759           0 :     free((char *) arg1); {
   13760           0 :       errorObj *ms_error = msGetErrorObj();
   13761             :       
   13762           0 :       switch(ms_error->code) {
   13763             :       case MS_NOERR:
   13764             :         break;
   13765           0 :       case MS_NOTFOUND:
   13766           0 :         msResetErrorList();
   13767           0 :         break;
   13768             :       case -1:
   13769             :         break;
   13770           0 :       case MS_IOERR:
   13771           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   13772           0 :           _raise_ms_exception();
   13773           0 :           msResetErrorList();
   13774           0 :           return NULL;
   13775             :         }
   13776             :       default:
   13777           0 :         _raise_ms_exception();
   13778           0 :         msResetErrorList();
   13779           0 :         return NULL;
   13780             :       }
   13781             :       
   13782             :     }
   13783             :   }
   13784             :   resultobj = SWIG_Py_Void();
   13785           0 :   return resultobj;
   13786           0 : fail:
   13787             :   return NULL;
   13788             : }
   13789             : 
   13790             : 
   13791           1 : SWIGINTERN PyObject *labelLeaderObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13792             :   PyObject *obj;
   13793           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   13794           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_labelLeaderObj, SWIG_NewClientData(obj));
   13795           1 :   return SWIG_Py_Void();
   13796             : }
   13797             : 
   13798           0 : SWIGINTERN PyObject *_wrap_labelObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13799             :   PyObject *resultobj = 0;
   13800             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13801           0 :   void *argp1 = 0 ;
   13802             :   int res1 = 0 ;
   13803           0 :   PyObject * obj0 = 0 ;
   13804             :   int result;
   13805             :   
   13806           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_refcount_get",&obj0)) SWIG_fail;
   13807           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13808           0 :   if (!SWIG_IsOK(res1)) {
   13809           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_refcount_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13810             :   }
   13811           0 :   arg1 = (struct labelObj *)(argp1);
   13812           0 :   result = (int) ((arg1)->refcount);
   13813             :   resultobj = SWIG_From_int((int)(result));
   13814           0 :   return resultobj;
   13815           0 : fail:
   13816             :   return NULL;
   13817             : }
   13818             : 
   13819             : 
   13820           1 : SWIGINTERN PyObject *_wrap_labelObj_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13821             :   PyObject *resultobj = 0;
   13822             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13823             :   char *arg2 = (char *) 0 ;
   13824           1 :   void *argp1 = 0 ;
   13825             :   int res1 = 0 ;
   13826             :   int res2 ;
   13827           1 :   char *buf2 = 0 ;
   13828           1 :   int alloc2 = 0 ;
   13829           1 :   PyObject * obj0 = 0 ;
   13830           1 :   PyObject * obj1 = 0 ;
   13831             :   
   13832           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_font_set",&obj0,&obj1)) SWIG_fail;
   13833           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13834           1 :   if (!SWIG_IsOK(res1)) {
   13835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_font_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13836             :   }
   13837           1 :   arg1 = (struct labelObj *)(argp1);
   13838           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   13839           1 :   if (!SWIG_IsOK(res2)) {
   13840           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_font_set" "', argument " "2"" of type '" "char *""'");
   13841             :   }
   13842           1 :   arg2 = (char *)(buf2);
   13843             :   {
   13844           1 :     if (arg1->font) free((char*)arg1->font);
   13845           1 :     if (arg2) {
   13846           1 :       arg1->font = (char *) malloc(strlen(arg2)+1);
   13847             :       strcpy((char*)arg1->font,arg2);
   13848             :     } else {
   13849           0 :       arg1->font = 0;
   13850             :     }
   13851             :   }
   13852             :   resultobj = SWIG_Py_Void();
   13853           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   13854             :   return resultobj;
   13855           0 : fail:
   13856           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   13857             :   return NULL;
   13858             : }
   13859             : 
   13860             : 
   13861           0 : SWIGINTERN PyObject *_wrap_labelObj_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13862             :   PyObject *resultobj = 0;
   13863             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13864           0 :   void *argp1 = 0 ;
   13865             :   int res1 = 0 ;
   13866           0 :   PyObject * obj0 = 0 ;
   13867             :   char *result = 0 ;
   13868             :   
   13869           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_font_get",&obj0)) SWIG_fail;
   13870           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13871           0 :   if (!SWIG_IsOK(res1)) {
   13872           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_font_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13873             :   }
   13874           0 :   arg1 = (struct labelObj *)(argp1);
   13875           0 :   result = (char *) ((arg1)->font);
   13876           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   13877           0 :   return resultobj;
   13878           0 : fail:
   13879             :   return NULL;
   13880             : }
   13881             : 
   13882             : 
   13883           0 : SWIGINTERN PyObject *_wrap_labelObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13884             :   PyObject *resultobj = 0;
   13885             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13886             :   colorObj *arg2 = (colorObj *) 0 ;
   13887           0 :   void *argp1 = 0 ;
   13888             :   int res1 = 0 ;
   13889           0 :   void *argp2 = 0 ;
   13890             :   int res2 = 0 ;
   13891           0 :   PyObject * obj0 = 0 ;
   13892           0 :   PyObject * obj1 = 0 ;
   13893             :   
   13894           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_color_set",&obj0,&obj1)) SWIG_fail;
   13895           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13896           0 :   if (!SWIG_IsOK(res1)) {
   13897           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_color_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13898             :   }
   13899           0 :   arg1 = (struct labelObj *)(argp1);
   13900           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   13901           0 :   if (!SWIG_IsOK(res2)) {
   13902           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_color_set" "', argument " "2"" of type '" "colorObj *""'"); 
   13903             :   }
   13904           0 :   arg2 = (colorObj *)(argp2);
   13905           0 :   if (arg1) (arg1)->color = *arg2;
   13906             :   resultobj = SWIG_Py_Void();
   13907           0 :   return resultobj;
   13908           0 : fail:
   13909             :   return NULL;
   13910             : }
   13911             : 
   13912             : 
   13913           1 : SWIGINTERN PyObject *_wrap_labelObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13914             :   PyObject *resultobj = 0;
   13915             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13916           1 :   void *argp1 = 0 ;
   13917             :   int res1 = 0 ;
   13918           1 :   PyObject * obj0 = 0 ;
   13919             :   colorObj *result = 0 ;
   13920             :   
   13921           1 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_color_get",&obj0)) SWIG_fail;
   13922           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13923           1 :   if (!SWIG_IsOK(res1)) {
   13924           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_color_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13925             :   }
   13926           1 :   arg1 = (struct labelObj *)(argp1);
   13927           1 :   result = (colorObj *)& ((arg1)->color);
   13928           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   13929           1 :   return resultobj;
   13930           0 : fail:
   13931             :   return NULL;
   13932             : }
   13933             : 
   13934             : 
   13935           0 : SWIGINTERN PyObject *_wrap_labelObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13936             :   PyObject *resultobj = 0;
   13937             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13938             :   colorObj *arg2 = (colorObj *) 0 ;
   13939           0 :   void *argp1 = 0 ;
   13940             :   int res1 = 0 ;
   13941           0 :   void *argp2 = 0 ;
   13942             :   int res2 = 0 ;
   13943           0 :   PyObject * obj0 = 0 ;
   13944           0 :   PyObject * obj1 = 0 ;
   13945             :   
   13946           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
   13947           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13948           0 :   if (!SWIG_IsOK(res1)) {
   13949           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinecolor_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13950             :   }
   13951           0 :   arg1 = (struct labelObj *)(argp1);
   13952           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   13953           0 :   if (!SWIG_IsOK(res2)) {
   13954           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   13955             :   }
   13956           0 :   arg2 = (colorObj *)(argp2);
   13957           0 :   if (arg1) (arg1)->outlinecolor = *arg2;
   13958             :   resultobj = SWIG_Py_Void();
   13959           0 :   return resultobj;
   13960           0 : fail:
   13961             :   return NULL;
   13962             : }
   13963             : 
   13964             : 
   13965           1 : SWIGINTERN PyObject *_wrap_labelObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13966             :   PyObject *resultobj = 0;
   13967             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13968           1 :   void *argp1 = 0 ;
   13969             :   int res1 = 0 ;
   13970           1 :   PyObject * obj0 = 0 ;
   13971             :   colorObj *result = 0 ;
   13972             :   
   13973           1 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_outlinecolor_get",&obj0)) SWIG_fail;
   13974           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   13975           1 :   if (!SWIG_IsOK(res1)) {
   13976           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinecolor_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   13977             :   }
   13978           1 :   arg1 = (struct labelObj *)(argp1);
   13979           1 :   result = (colorObj *)& ((arg1)->outlinecolor);
   13980           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   13981           1 :   return resultobj;
   13982           0 : fail:
   13983             :   return NULL;
   13984             : }
   13985             : 
   13986             : 
   13987           0 : SWIGINTERN PyObject *_wrap_labelObj_outlinewidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   13988             :   PyObject *resultobj = 0;
   13989             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   13990             :   int arg2 ;
   13991           0 :   void *argp1 = 0 ;
   13992             :   int res1 = 0 ;
   13993             :   int val2 ;
   13994             :   int ecode2 = 0 ;
   13995           0 :   PyObject * obj0 = 0 ;
   13996           0 :   PyObject * obj1 = 0 ;
   13997             :   
   13998           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_outlinewidth_set",&obj0,&obj1)) SWIG_fail;
   13999           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14000           0 :   if (!SWIG_IsOK(res1)) {
   14001           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinewidth_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14002             :   }
   14003           0 :   arg1 = (struct labelObj *)(argp1);
   14004           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14005           0 :   if (!SWIG_IsOK(ecode2)) {
   14006           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_outlinewidth_set" "', argument " "2"" of type '" "int""'");
   14007             :   } 
   14008             :   arg2 = (int)(val2);
   14009           0 :   if (arg1) (arg1)->outlinewidth = arg2;
   14010             :   resultobj = SWIG_Py_Void();
   14011           0 :   return resultobj;
   14012           0 : fail:
   14013             :   return NULL;
   14014             : }
   14015             : 
   14016             : 
   14017           0 : SWIGINTERN PyObject *_wrap_labelObj_outlinewidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14018             :   PyObject *resultobj = 0;
   14019             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14020           0 :   void *argp1 = 0 ;
   14021             :   int res1 = 0 ;
   14022           0 :   PyObject * obj0 = 0 ;
   14023             :   int result;
   14024             :   
   14025           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_outlinewidth_get",&obj0)) SWIG_fail;
   14026           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14027           0 :   if (!SWIG_IsOK(res1)) {
   14028           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinewidth_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14029             :   }
   14030           0 :   arg1 = (struct labelObj *)(argp1);
   14031           0 :   result = (int) ((arg1)->outlinewidth);
   14032             :   resultobj = SWIG_From_int((int)(result));
   14033           0 :   return resultobj;
   14034           0 : fail:
   14035             :   return NULL;
   14036             : }
   14037             : 
   14038             : 
   14039           0 : SWIGINTERN PyObject *_wrap_labelObj_shadowcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14040             :   PyObject *resultobj = 0;
   14041             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14042             :   colorObj *arg2 = (colorObj *) 0 ;
   14043           0 :   void *argp1 = 0 ;
   14044             :   int res1 = 0 ;
   14045           0 :   void *argp2 = 0 ;
   14046             :   int res2 = 0 ;
   14047           0 :   PyObject * obj0 = 0 ;
   14048           0 :   PyObject * obj1 = 0 ;
   14049             :   
   14050           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_shadowcolor_set",&obj0,&obj1)) SWIG_fail;
   14051           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14052           0 :   if (!SWIG_IsOK(res1)) {
   14053           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowcolor_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14054             :   }
   14055           0 :   arg1 = (struct labelObj *)(argp1);
   14056           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   14057           0 :   if (!SWIG_IsOK(res2)) {
   14058           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_shadowcolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   14059             :   }
   14060           0 :   arg2 = (colorObj *)(argp2);
   14061           0 :   if (arg1) (arg1)->shadowcolor = *arg2;
   14062             :   resultobj = SWIG_Py_Void();
   14063           0 :   return resultobj;
   14064           0 : fail:
   14065             :   return NULL;
   14066             : }
   14067             : 
   14068             : 
   14069           0 : SWIGINTERN PyObject *_wrap_labelObj_shadowcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14070             :   PyObject *resultobj = 0;
   14071             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14072           0 :   void *argp1 = 0 ;
   14073             :   int res1 = 0 ;
   14074           0 :   PyObject * obj0 = 0 ;
   14075             :   colorObj *result = 0 ;
   14076             :   
   14077           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_shadowcolor_get",&obj0)) SWIG_fail;
   14078           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14079           0 :   if (!SWIG_IsOK(res1)) {
   14080           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowcolor_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14081             :   }
   14082           0 :   arg1 = (struct labelObj *)(argp1);
   14083           0 :   result = (colorObj *)& ((arg1)->shadowcolor);
   14084           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   14085           0 :   return resultobj;
   14086           0 : fail:
   14087             :   return NULL;
   14088             : }
   14089             : 
   14090             : 
   14091           0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14092             :   PyObject *resultobj = 0;
   14093             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14094             :   int arg2 ;
   14095           0 :   void *argp1 = 0 ;
   14096             :   int res1 = 0 ;
   14097             :   int val2 ;
   14098             :   int ecode2 = 0 ;
   14099           0 :   PyObject * obj0 = 0 ;
   14100           0 :   PyObject * obj1 = 0 ;
   14101             :   
   14102           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_shadowsizex_set",&obj0,&obj1)) SWIG_fail;
   14103           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14104           0 :   if (!SWIG_IsOK(res1)) {
   14105           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizex_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14106             :   }
   14107           0 :   arg1 = (struct labelObj *)(argp1);
   14108           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14109           0 :   if (!SWIG_IsOK(ecode2)) {
   14110           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_shadowsizex_set" "', argument " "2"" of type '" "int""'");
   14111             :   } 
   14112             :   arg2 = (int)(val2);
   14113           0 :   if (arg1) (arg1)->shadowsizex = arg2;
   14114             :   resultobj = SWIG_Py_Void();
   14115           0 :   return resultobj;
   14116           0 : fail:
   14117             :   return NULL;
   14118             : }
   14119             : 
   14120             : 
   14121           0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14122             :   PyObject *resultobj = 0;
   14123             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14124           0 :   void *argp1 = 0 ;
   14125             :   int res1 = 0 ;
   14126           0 :   PyObject * obj0 = 0 ;
   14127             :   int result;
   14128             :   
   14129           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_shadowsizex_get",&obj0)) SWIG_fail;
   14130           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14131           0 :   if (!SWIG_IsOK(res1)) {
   14132           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizex_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14133             :   }
   14134           0 :   arg1 = (struct labelObj *)(argp1);
   14135           0 :   result = (int) ((arg1)->shadowsizex);
   14136             :   resultobj = SWIG_From_int((int)(result));
   14137           0 :   return resultobj;
   14138           0 : fail:
   14139             :   return NULL;
   14140             : }
   14141             : 
   14142             : 
   14143           0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14144             :   PyObject *resultobj = 0;
   14145             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14146             :   int arg2 ;
   14147           0 :   void *argp1 = 0 ;
   14148             :   int res1 = 0 ;
   14149             :   int val2 ;
   14150             :   int ecode2 = 0 ;
   14151           0 :   PyObject * obj0 = 0 ;
   14152           0 :   PyObject * obj1 = 0 ;
   14153             :   
   14154           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_shadowsizey_set",&obj0,&obj1)) SWIG_fail;
   14155           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14156           0 :   if (!SWIG_IsOK(res1)) {
   14157           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizey_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14158             :   }
   14159           0 :   arg1 = (struct labelObj *)(argp1);
   14160           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14161           0 :   if (!SWIG_IsOK(ecode2)) {
   14162           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_shadowsizey_set" "', argument " "2"" of type '" "int""'");
   14163             :   } 
   14164             :   arg2 = (int)(val2);
   14165           0 :   if (arg1) (arg1)->shadowsizey = arg2;
   14166             :   resultobj = SWIG_Py_Void();
   14167           0 :   return resultobj;
   14168           0 : fail:
   14169             :   return NULL;
   14170             : }
   14171             : 
   14172             : 
   14173           0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14174             :   PyObject *resultobj = 0;
   14175             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14176           0 :   void *argp1 = 0 ;
   14177             :   int res1 = 0 ;
   14178           0 :   PyObject * obj0 = 0 ;
   14179             :   int result;
   14180             :   
   14181           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_shadowsizey_get",&obj0)) SWIG_fail;
   14182           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14183           0 :   if (!SWIG_IsOK(res1)) {
   14184           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizey_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14185             :   }
   14186           0 :   arg1 = (struct labelObj *)(argp1);
   14187           0 :   result = (int) ((arg1)->shadowsizey);
   14188             :   resultobj = SWIG_From_int((int)(result));
   14189           0 :   return resultobj;
   14190           0 : fail:
   14191             :   return NULL;
   14192             : }
   14193             : 
   14194             : 
   14195           1 : SWIGINTERN PyObject *_wrap_labelObj_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14196             :   PyObject *resultobj = 0;
   14197             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14198             :   int arg2 ;
   14199           1 :   void *argp1 = 0 ;
   14200             :   int res1 = 0 ;
   14201             :   int val2 ;
   14202             :   int ecode2 = 0 ;
   14203           1 :   PyObject * obj0 = 0 ;
   14204           1 :   PyObject * obj1 = 0 ;
   14205             :   
   14206           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_size_set",&obj0,&obj1)) SWIG_fail;
   14207           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14208           1 :   if (!SWIG_IsOK(res1)) {
   14209           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_size_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14210             :   }
   14211           1 :   arg1 = (struct labelObj *)(argp1);
   14212           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14213           1 :   if (!SWIG_IsOK(ecode2)) {
   14214           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_size_set" "', argument " "2"" of type '" "int""'");
   14215             :   } 
   14216             :   arg2 = (int)(val2);
   14217           1 :   if (arg1) (arg1)->size = arg2;
   14218             :   resultobj = SWIG_Py_Void();
   14219           1 :   return resultobj;
   14220           0 : fail:
   14221             :   return NULL;
   14222             : }
   14223             : 
   14224             : 
   14225           0 : SWIGINTERN PyObject *_wrap_labelObj_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14226             :   PyObject *resultobj = 0;
   14227             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14228           0 :   void *argp1 = 0 ;
   14229             :   int res1 = 0 ;
   14230           0 :   PyObject * obj0 = 0 ;
   14231             :   int result;
   14232             :   
   14233           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_size_get",&obj0)) SWIG_fail;
   14234           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14235           0 :   if (!SWIG_IsOK(res1)) {
   14236           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_size_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14237             :   }
   14238           0 :   arg1 = (struct labelObj *)(argp1);
   14239           0 :   result = (int) ((arg1)->size);
   14240             :   resultobj = SWIG_From_int((int)(result));
   14241           0 :   return resultobj;
   14242           0 : fail:
   14243             :   return NULL;
   14244             : }
   14245             : 
   14246             : 
   14247           0 : SWIGINTERN PyObject *_wrap_labelObj_minsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14248             :   PyObject *resultobj = 0;
   14249             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14250             :   int arg2 ;
   14251           0 :   void *argp1 = 0 ;
   14252             :   int res1 = 0 ;
   14253             :   int val2 ;
   14254             :   int ecode2 = 0 ;
   14255           0 :   PyObject * obj0 = 0 ;
   14256           0 :   PyObject * obj1 = 0 ;
   14257             :   
   14258           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minsize_set",&obj0,&obj1)) SWIG_fail;
   14259           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14260           0 :   if (!SWIG_IsOK(res1)) {
   14261           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minsize_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14262             :   }
   14263           0 :   arg1 = (struct labelObj *)(argp1);
   14264           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14265           0 :   if (!SWIG_IsOK(ecode2)) {
   14266           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minsize_set" "', argument " "2"" of type '" "int""'");
   14267             :   } 
   14268             :   arg2 = (int)(val2);
   14269           0 :   if (arg1) (arg1)->minsize = arg2;
   14270             :   resultobj = SWIG_Py_Void();
   14271           0 :   return resultobj;
   14272           0 : fail:
   14273             :   return NULL;
   14274             : }
   14275             : 
   14276             : 
   14277           0 : SWIGINTERN PyObject *_wrap_labelObj_minsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14278             :   PyObject *resultobj = 0;
   14279             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14280           0 :   void *argp1 = 0 ;
   14281             :   int res1 = 0 ;
   14282           0 :   PyObject * obj0 = 0 ;
   14283             :   int result;
   14284             :   
   14285           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minsize_get",&obj0)) SWIG_fail;
   14286           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14287           0 :   if (!SWIG_IsOK(res1)) {
   14288           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minsize_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14289             :   }
   14290           0 :   arg1 = (struct labelObj *)(argp1);
   14291           0 :   result = (int) ((arg1)->minsize);
   14292             :   resultobj = SWIG_From_int((int)(result));
   14293           0 :   return resultobj;
   14294           0 : fail:
   14295             :   return NULL;
   14296             : }
   14297             : 
   14298             : 
   14299           0 : SWIGINTERN PyObject *_wrap_labelObj_maxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14300             :   PyObject *resultobj = 0;
   14301             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14302             :   int arg2 ;
   14303           0 :   void *argp1 = 0 ;
   14304             :   int res1 = 0 ;
   14305             :   int val2 ;
   14306             :   int ecode2 = 0 ;
   14307           0 :   PyObject * obj0 = 0 ;
   14308           0 :   PyObject * obj1 = 0 ;
   14309             :   
   14310           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxsize_set",&obj0,&obj1)) SWIG_fail;
   14311           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14312           0 :   if (!SWIG_IsOK(res1)) {
   14313           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxsize_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14314             :   }
   14315           0 :   arg1 = (struct labelObj *)(argp1);
   14316           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14317           0 :   if (!SWIG_IsOK(ecode2)) {
   14318           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxsize_set" "', argument " "2"" of type '" "int""'");
   14319             :   } 
   14320             :   arg2 = (int)(val2);
   14321           0 :   if (arg1) (arg1)->maxsize = arg2;
   14322             :   resultobj = SWIG_Py_Void();
   14323           0 :   return resultobj;
   14324           0 : fail:
   14325             :   return NULL;
   14326             : }
   14327             : 
   14328             : 
   14329           0 : SWIGINTERN PyObject *_wrap_labelObj_maxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14330             :   PyObject *resultobj = 0;
   14331             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14332           0 :   void *argp1 = 0 ;
   14333             :   int res1 = 0 ;
   14334           0 :   PyObject * obj0 = 0 ;
   14335             :   int result;
   14336             :   
   14337           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxsize_get",&obj0)) SWIG_fail;
   14338           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14339           0 :   if (!SWIG_IsOK(res1)) {
   14340           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxsize_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14341             :   }
   14342           0 :   arg1 = (struct labelObj *)(argp1);
   14343           0 :   result = (int) ((arg1)->maxsize);
   14344             :   resultobj = SWIG_From_int((int)(result));
   14345           0 :   return resultobj;
   14346           0 : fail:
   14347             :   return NULL;
   14348             : }
   14349             : 
   14350             : 
   14351           0 : SWIGINTERN PyObject *_wrap_labelObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14352             :   PyObject *resultobj = 0;
   14353             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14354             :   int arg2 ;
   14355           0 :   void *argp1 = 0 ;
   14356             :   int res1 = 0 ;
   14357             :   int val2 ;
   14358             :   int ecode2 = 0 ;
   14359           0 :   PyObject * obj0 = 0 ;
   14360           0 :   PyObject * obj1 = 0 ;
   14361             :   
   14362           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_position_set",&obj0,&obj1)) SWIG_fail;
   14363           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14364           0 :   if (!SWIG_IsOK(res1)) {
   14365           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_position_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14366             :   }
   14367           0 :   arg1 = (struct labelObj *)(argp1);
   14368           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14369           0 :   if (!SWIG_IsOK(ecode2)) {
   14370           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_position_set" "', argument " "2"" of type '" "int""'");
   14371             :   } 
   14372             :   arg2 = (int)(val2);
   14373           0 :   if (arg1) (arg1)->position = arg2;
   14374             :   resultobj = SWIG_Py_Void();
   14375           0 :   return resultobj;
   14376           0 : fail:
   14377             :   return NULL;
   14378             : }
   14379             : 
   14380             : 
   14381           0 : SWIGINTERN PyObject *_wrap_labelObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14382             :   PyObject *resultobj = 0;
   14383             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14384           0 :   void *argp1 = 0 ;
   14385             :   int res1 = 0 ;
   14386           0 :   PyObject * obj0 = 0 ;
   14387             :   int result;
   14388             :   
   14389           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_position_get",&obj0)) SWIG_fail;
   14390           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14391           0 :   if (!SWIG_IsOK(res1)) {
   14392           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_position_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14393             :   }
   14394           0 :   arg1 = (struct labelObj *)(argp1);
   14395           0 :   result = (int) ((arg1)->position);
   14396             :   resultobj = SWIG_From_int((int)(result));
   14397           0 :   return resultobj;
   14398           0 : fail:
   14399             :   return NULL;
   14400             : }
   14401             : 
   14402             : 
   14403           0 : SWIGINTERN PyObject *_wrap_labelObj_offsetx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14404             :   PyObject *resultobj = 0;
   14405             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14406             :   int arg2 ;
   14407           0 :   void *argp1 = 0 ;
   14408             :   int res1 = 0 ;
   14409             :   int val2 ;
   14410             :   int ecode2 = 0 ;
   14411           0 :   PyObject * obj0 = 0 ;
   14412           0 :   PyObject * obj1 = 0 ;
   14413             :   
   14414           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_offsetx_set",&obj0,&obj1)) SWIG_fail;
   14415           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14416           0 :   if (!SWIG_IsOK(res1)) {
   14417           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsetx_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14418             :   }
   14419           0 :   arg1 = (struct labelObj *)(argp1);
   14420           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14421           0 :   if (!SWIG_IsOK(ecode2)) {
   14422           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_offsetx_set" "', argument " "2"" of type '" "int""'");
   14423             :   } 
   14424             :   arg2 = (int)(val2);
   14425           0 :   if (arg1) (arg1)->offsetx = arg2;
   14426             :   resultobj = SWIG_Py_Void();
   14427           0 :   return resultobj;
   14428           0 : fail:
   14429             :   return NULL;
   14430             : }
   14431             : 
   14432             : 
   14433           0 : SWIGINTERN PyObject *_wrap_labelObj_offsetx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14434             :   PyObject *resultobj = 0;
   14435             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14436           0 :   void *argp1 = 0 ;
   14437             :   int res1 = 0 ;
   14438           0 :   PyObject * obj0 = 0 ;
   14439             :   int result;
   14440             :   
   14441           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_offsetx_get",&obj0)) SWIG_fail;
   14442           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14443           0 :   if (!SWIG_IsOK(res1)) {
   14444           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsetx_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14445             :   }
   14446           0 :   arg1 = (struct labelObj *)(argp1);
   14447           0 :   result = (int) ((arg1)->offsetx);
   14448             :   resultobj = SWIG_From_int((int)(result));
   14449           0 :   return resultobj;
   14450           0 : fail:
   14451             :   return NULL;
   14452             : }
   14453             : 
   14454             : 
   14455           0 : SWIGINTERN PyObject *_wrap_labelObj_offsety_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14456             :   PyObject *resultobj = 0;
   14457             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14458             :   int arg2 ;
   14459           0 :   void *argp1 = 0 ;
   14460             :   int res1 = 0 ;
   14461             :   int val2 ;
   14462             :   int ecode2 = 0 ;
   14463           0 :   PyObject * obj0 = 0 ;
   14464           0 :   PyObject * obj1 = 0 ;
   14465             :   
   14466           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_offsety_set",&obj0,&obj1)) SWIG_fail;
   14467           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14468           0 :   if (!SWIG_IsOK(res1)) {
   14469           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsety_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14470             :   }
   14471           0 :   arg1 = (struct labelObj *)(argp1);
   14472           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14473           0 :   if (!SWIG_IsOK(ecode2)) {
   14474           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_offsety_set" "', argument " "2"" of type '" "int""'");
   14475             :   } 
   14476             :   arg2 = (int)(val2);
   14477           0 :   if (arg1) (arg1)->offsety = arg2;
   14478             :   resultobj = SWIG_Py_Void();
   14479           0 :   return resultobj;
   14480           0 : fail:
   14481             :   return NULL;
   14482             : }
   14483             : 
   14484             : 
   14485           0 : SWIGINTERN PyObject *_wrap_labelObj_offsety_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14486             :   PyObject *resultobj = 0;
   14487             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14488           0 :   void *argp1 = 0 ;
   14489             :   int res1 = 0 ;
   14490           0 :   PyObject * obj0 = 0 ;
   14491             :   int result;
   14492             :   
   14493           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_offsety_get",&obj0)) SWIG_fail;
   14494           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14495           0 :   if (!SWIG_IsOK(res1)) {
   14496           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsety_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14497             :   }
   14498           0 :   arg1 = (struct labelObj *)(argp1);
   14499           0 :   result = (int) ((arg1)->offsety);
   14500             :   resultobj = SWIG_From_int((int)(result));
   14501           0 :   return resultobj;
   14502           0 : fail:
   14503             :   return NULL;
   14504             : }
   14505             : 
   14506             : 
   14507           0 : SWIGINTERN PyObject *_wrap_labelObj_angle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14508             :   PyObject *resultobj = 0;
   14509             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14510             :   double arg2 ;
   14511           0 :   void *argp1 = 0 ;
   14512             :   int res1 = 0 ;
   14513             :   double val2 ;
   14514             :   int ecode2 = 0 ;
   14515           0 :   PyObject * obj0 = 0 ;
   14516           0 :   PyObject * obj1 = 0 ;
   14517             :   
   14518           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_angle_set",&obj0,&obj1)) SWIG_fail;
   14519           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14520           0 :   if (!SWIG_IsOK(res1)) {
   14521           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_angle_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14522             :   }
   14523           0 :   arg1 = (struct labelObj *)(argp1);
   14524           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   14525           0 :   if (!SWIG_IsOK(ecode2)) {
   14526           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_angle_set" "', argument " "2"" of type '" "double""'");
   14527             :   } 
   14528           0 :   arg2 = (double)(val2);
   14529           0 :   if (arg1) (arg1)->angle = arg2;
   14530             :   resultobj = SWIG_Py_Void();
   14531           0 :   return resultobj;
   14532           0 : fail:
   14533             :   return NULL;
   14534             : }
   14535             : 
   14536             : 
   14537           0 : SWIGINTERN PyObject *_wrap_labelObj_angle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14538             :   PyObject *resultobj = 0;
   14539             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14540           0 :   void *argp1 = 0 ;
   14541             :   int res1 = 0 ;
   14542           0 :   PyObject * obj0 = 0 ;
   14543             :   double result;
   14544             :   
   14545           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_angle_get",&obj0)) SWIG_fail;
   14546           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14547           0 :   if (!SWIG_IsOK(res1)) {
   14548           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_angle_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14549             :   }
   14550           0 :   arg1 = (struct labelObj *)(argp1);
   14551           0 :   result = (double) ((arg1)->angle);
   14552           0 :   resultobj = SWIG_From_double((double)(result));
   14553           0 :   return resultobj;
   14554           0 : fail:
   14555             :   return NULL;
   14556             : }
   14557             : 
   14558             : 
   14559           0 : SWIGINTERN PyObject *_wrap_labelObj_anglemode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14560             :   PyObject *resultobj = 0;
   14561             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14562             :   enum MS_POSITIONS_ENUM arg2 ;
   14563           0 :   void *argp1 = 0 ;
   14564             :   int res1 = 0 ;
   14565             :   int val2 ;
   14566             :   int ecode2 = 0 ;
   14567           0 :   PyObject * obj0 = 0 ;
   14568           0 :   PyObject * obj1 = 0 ;
   14569             :   
   14570           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_anglemode_set",&obj0,&obj1)) SWIG_fail;
   14571           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14572           0 :   if (!SWIG_IsOK(res1)) {
   14573           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_anglemode_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14574             :   }
   14575           0 :   arg1 = (struct labelObj *)(argp1);
   14576           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14577           0 :   if (!SWIG_IsOK(ecode2)) {
   14578           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_anglemode_set" "', argument " "2"" of type '" "enum MS_POSITIONS_ENUM""'");
   14579             :   } 
   14580           0 :   arg2 = (enum MS_POSITIONS_ENUM)(val2);
   14581           0 :   if (arg1) (arg1)->anglemode = arg2;
   14582             :   resultobj = SWIG_Py_Void();
   14583           0 :   return resultobj;
   14584           0 : fail:
   14585             :   return NULL;
   14586             : }
   14587             : 
   14588             : 
   14589           0 : SWIGINTERN PyObject *_wrap_labelObj_anglemode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14590             :   PyObject *resultobj = 0;
   14591             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14592           0 :   void *argp1 = 0 ;
   14593             :   int res1 = 0 ;
   14594           0 :   PyObject * obj0 = 0 ;
   14595             :   enum MS_POSITIONS_ENUM result;
   14596             :   
   14597           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_anglemode_get",&obj0)) SWIG_fail;
   14598           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14599           0 :   if (!SWIG_IsOK(res1)) {
   14600           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_anglemode_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14601             :   }
   14602           0 :   arg1 = (struct labelObj *)(argp1);
   14603           0 :   result = (enum MS_POSITIONS_ENUM) ((arg1)->anglemode);
   14604           0 :   resultobj = SWIG_From_int((int)(result));
   14605           0 :   return resultobj;
   14606           0 : fail:
   14607             :   return NULL;
   14608             : }
   14609             : 
   14610             : 
   14611           0 : SWIGINTERN PyObject *_wrap_labelObj_buffer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14612             :   PyObject *resultobj = 0;
   14613             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14614             :   int arg2 ;
   14615           0 :   void *argp1 = 0 ;
   14616             :   int res1 = 0 ;
   14617             :   int val2 ;
   14618             :   int ecode2 = 0 ;
   14619           0 :   PyObject * obj0 = 0 ;
   14620           0 :   PyObject * obj1 = 0 ;
   14621             :   
   14622           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_buffer_set",&obj0,&obj1)) SWIG_fail;
   14623           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14624           0 :   if (!SWIG_IsOK(res1)) {
   14625           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_buffer_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14626             :   }
   14627           0 :   arg1 = (struct labelObj *)(argp1);
   14628           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14629           0 :   if (!SWIG_IsOK(ecode2)) {
   14630           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_buffer_set" "', argument " "2"" of type '" "int""'");
   14631             :   } 
   14632             :   arg2 = (int)(val2);
   14633           0 :   if (arg1) (arg1)->buffer = arg2;
   14634             :   resultobj = SWIG_Py_Void();
   14635           0 :   return resultobj;
   14636           0 : fail:
   14637             :   return NULL;
   14638             : }
   14639             : 
   14640             : 
   14641           0 : SWIGINTERN PyObject *_wrap_labelObj_buffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14642             :   PyObject *resultobj = 0;
   14643             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14644           0 :   void *argp1 = 0 ;
   14645             :   int res1 = 0 ;
   14646           0 :   PyObject * obj0 = 0 ;
   14647             :   int result;
   14648             :   
   14649           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_buffer_get",&obj0)) SWIG_fail;
   14650           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14651           0 :   if (!SWIG_IsOK(res1)) {
   14652           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_buffer_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14653             :   }
   14654           0 :   arg1 = (struct labelObj *)(argp1);
   14655           0 :   result = (int) ((arg1)->buffer);
   14656             :   resultobj = SWIG_From_int((int)(result));
   14657           0 :   return resultobj;
   14658           0 : fail:
   14659             :   return NULL;
   14660             : }
   14661             : 
   14662             : 
   14663           0 : SWIGINTERN PyObject *_wrap_labelObj_align_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14664             :   PyObject *resultobj = 0;
   14665             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14666             :   int arg2 ;
   14667           0 :   void *argp1 = 0 ;
   14668             :   int res1 = 0 ;
   14669             :   int val2 ;
   14670             :   int ecode2 = 0 ;
   14671           0 :   PyObject * obj0 = 0 ;
   14672           0 :   PyObject * obj1 = 0 ;
   14673             :   
   14674           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_align_set",&obj0,&obj1)) SWIG_fail;
   14675           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14676           0 :   if (!SWIG_IsOK(res1)) {
   14677           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_align_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14678             :   }
   14679           0 :   arg1 = (struct labelObj *)(argp1);
   14680           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14681           0 :   if (!SWIG_IsOK(ecode2)) {
   14682           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_align_set" "', argument " "2"" of type '" "int""'");
   14683             :   } 
   14684             :   arg2 = (int)(val2);
   14685           0 :   if (arg1) (arg1)->align = arg2;
   14686             :   resultobj = SWIG_Py_Void();
   14687           0 :   return resultobj;
   14688           0 : fail:
   14689             :   return NULL;
   14690             : }
   14691             : 
   14692             : 
   14693           0 : SWIGINTERN PyObject *_wrap_labelObj_align_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14694             :   PyObject *resultobj = 0;
   14695             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14696           0 :   void *argp1 = 0 ;
   14697             :   int res1 = 0 ;
   14698           0 :   PyObject * obj0 = 0 ;
   14699             :   int result;
   14700             :   
   14701           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_align_get",&obj0)) SWIG_fail;
   14702           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14703           0 :   if (!SWIG_IsOK(res1)) {
   14704           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_align_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14705             :   }
   14706           0 :   arg1 = (struct labelObj *)(argp1);
   14707           0 :   result = (int) ((arg1)->align);
   14708             :   resultobj = SWIG_From_int((int)(result));
   14709           0 :   return resultobj;
   14710           0 : fail:
   14711             :   return NULL;
   14712             : }
   14713             : 
   14714             : 
   14715           0 : SWIGINTERN PyObject *_wrap_labelObj_wrap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14716             :   PyObject *resultobj = 0;
   14717             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14718             :   char arg2 ;
   14719           0 :   void *argp1 = 0 ;
   14720             :   int res1 = 0 ;
   14721             :   char val2 ;
   14722             :   int ecode2 = 0 ;
   14723           0 :   PyObject * obj0 = 0 ;
   14724           0 :   PyObject * obj1 = 0 ;
   14725             :   
   14726           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_wrap_set",&obj0,&obj1)) SWIG_fail;
   14727           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14728           0 :   if (!SWIG_IsOK(res1)) {
   14729           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_wrap_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14730             :   }
   14731           0 :   arg1 = (struct labelObj *)(argp1);
   14732           0 :   ecode2 = SWIG_AsVal_char(obj1, &val2);
   14733           0 :   if (!SWIG_IsOK(ecode2)) {
   14734           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_wrap_set" "', argument " "2"" of type '" "char""'");
   14735             :   } 
   14736           0 :   arg2 = (char)(val2);
   14737           0 :   if (arg1) (arg1)->wrap = arg2;
   14738             :   resultobj = SWIG_Py_Void();
   14739           0 :   return resultobj;
   14740           0 : fail:
   14741             :   return NULL;
   14742             : }
   14743             : 
   14744             : 
   14745           0 : SWIGINTERN PyObject *_wrap_labelObj_wrap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14746             :   PyObject *resultobj = 0;
   14747             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14748           0 :   void *argp1 = 0 ;
   14749             :   int res1 = 0 ;
   14750           0 :   PyObject * obj0 = 0 ;
   14751             :   char result;
   14752             :   
   14753           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_wrap_get",&obj0)) SWIG_fail;
   14754           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14755           0 :   if (!SWIG_IsOK(res1)) {
   14756           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_wrap_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14757             :   }
   14758           0 :   arg1 = (struct labelObj *)(argp1);
   14759           0 :   result = (char) ((arg1)->wrap);
   14760             :   resultobj = SWIG_From_char((char)(result));
   14761           0 :   return resultobj;
   14762           0 : fail:
   14763             :   return NULL;
   14764             : }
   14765             : 
   14766             : 
   14767           0 : SWIGINTERN PyObject *_wrap_labelObj_maxlength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14768             :   PyObject *resultobj = 0;
   14769             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14770             :   int arg2 ;
   14771           0 :   void *argp1 = 0 ;
   14772             :   int res1 = 0 ;
   14773             :   int val2 ;
   14774             :   int ecode2 = 0 ;
   14775           0 :   PyObject * obj0 = 0 ;
   14776           0 :   PyObject * obj1 = 0 ;
   14777             :   
   14778           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxlength_set",&obj0,&obj1)) SWIG_fail;
   14779           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14780           0 :   if (!SWIG_IsOK(res1)) {
   14781           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxlength_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14782             :   }
   14783           0 :   arg1 = (struct labelObj *)(argp1);
   14784           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14785           0 :   if (!SWIG_IsOK(ecode2)) {
   14786           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxlength_set" "', argument " "2"" of type '" "int""'");
   14787             :   } 
   14788             :   arg2 = (int)(val2);
   14789           0 :   if (arg1) (arg1)->maxlength = arg2;
   14790             :   resultobj = SWIG_Py_Void();
   14791           0 :   return resultobj;
   14792           0 : fail:
   14793             :   return NULL;
   14794             : }
   14795             : 
   14796             : 
   14797           0 : SWIGINTERN PyObject *_wrap_labelObj_maxlength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14798             :   PyObject *resultobj = 0;
   14799             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14800           0 :   void *argp1 = 0 ;
   14801             :   int res1 = 0 ;
   14802           0 :   PyObject * obj0 = 0 ;
   14803             :   int result;
   14804             :   
   14805           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxlength_get",&obj0)) SWIG_fail;
   14806           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14807           0 :   if (!SWIG_IsOK(res1)) {
   14808           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxlength_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14809             :   }
   14810           0 :   arg1 = (struct labelObj *)(argp1);
   14811           0 :   result = (int) ((arg1)->maxlength);
   14812             :   resultobj = SWIG_From_int((int)(result));
   14813           0 :   return resultobj;
   14814           0 : fail:
   14815             :   return NULL;
   14816             : }
   14817             : 
   14818             : 
   14819           0 : SWIGINTERN PyObject *_wrap_labelObj_minlength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14820             :   PyObject *resultobj = 0;
   14821             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14822             :   int arg2 ;
   14823           0 :   void *argp1 = 0 ;
   14824             :   int res1 = 0 ;
   14825             :   int val2 ;
   14826             :   int ecode2 = 0 ;
   14827           0 :   PyObject * obj0 = 0 ;
   14828           0 :   PyObject * obj1 = 0 ;
   14829             :   
   14830           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minlength_set",&obj0,&obj1)) SWIG_fail;
   14831           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14832           0 :   if (!SWIG_IsOK(res1)) {
   14833           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minlength_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14834             :   }
   14835           0 :   arg1 = (struct labelObj *)(argp1);
   14836           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14837           0 :   if (!SWIG_IsOK(ecode2)) {
   14838           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minlength_set" "', argument " "2"" of type '" "int""'");
   14839             :   } 
   14840             :   arg2 = (int)(val2);
   14841           0 :   if (arg1) (arg1)->minlength = arg2;
   14842             :   resultobj = SWIG_Py_Void();
   14843           0 :   return resultobj;
   14844           0 : fail:
   14845             :   return NULL;
   14846             : }
   14847             : 
   14848             : 
   14849           0 : SWIGINTERN PyObject *_wrap_labelObj_minlength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14850             :   PyObject *resultobj = 0;
   14851             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14852           0 :   void *argp1 = 0 ;
   14853             :   int res1 = 0 ;
   14854           0 :   PyObject * obj0 = 0 ;
   14855             :   int result;
   14856             :   
   14857           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minlength_get",&obj0)) SWIG_fail;
   14858           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14859           0 :   if (!SWIG_IsOK(res1)) {
   14860           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minlength_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14861             :   }
   14862           0 :   arg1 = (struct labelObj *)(argp1);
   14863           0 :   result = (int) ((arg1)->minlength);
   14864             :   resultobj = SWIG_From_int((int)(result));
   14865           0 :   return resultobj;
   14866           0 : fail:
   14867             :   return NULL;
   14868             : }
   14869             : 
   14870             : 
   14871           0 : SWIGINTERN PyObject *_wrap_labelObj_space_size_10_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14872             :   PyObject *resultobj = 0;
   14873             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14874             :   double arg2 ;
   14875           0 :   void *argp1 = 0 ;
   14876             :   int res1 = 0 ;
   14877             :   double val2 ;
   14878             :   int ecode2 = 0 ;
   14879           0 :   PyObject * obj0 = 0 ;
   14880           0 :   PyObject * obj1 = 0 ;
   14881             :   
   14882           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_space_size_10_set",&obj0,&obj1)) SWIG_fail;
   14883           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14884           0 :   if (!SWIG_IsOK(res1)) {
   14885           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_space_size_10_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14886             :   }
   14887           0 :   arg1 = (struct labelObj *)(argp1);
   14888           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   14889           0 :   if (!SWIG_IsOK(ecode2)) {
   14890           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_space_size_10_set" "', argument " "2"" of type '" "double""'");
   14891             :   } 
   14892           0 :   arg2 = (double)(val2);
   14893           0 :   if (arg1) (arg1)->space_size_10 = arg2;
   14894             :   resultobj = SWIG_Py_Void();
   14895           0 :   return resultobj;
   14896           0 : fail:
   14897             :   return NULL;
   14898             : }
   14899             : 
   14900             : 
   14901           0 : SWIGINTERN PyObject *_wrap_labelObj_space_size_10_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14902             :   PyObject *resultobj = 0;
   14903             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14904           0 :   void *argp1 = 0 ;
   14905             :   int res1 = 0 ;
   14906           0 :   PyObject * obj0 = 0 ;
   14907             :   double result;
   14908             :   
   14909           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_space_size_10_get",&obj0)) SWIG_fail;
   14910           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14911           0 :   if (!SWIG_IsOK(res1)) {
   14912           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_space_size_10_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14913             :   }
   14914           0 :   arg1 = (struct labelObj *)(argp1);
   14915           0 :   result = (double) ((arg1)->space_size_10);
   14916           0 :   resultobj = SWIG_From_double((double)(result));
   14917           0 :   return resultobj;
   14918           0 : fail:
   14919             :   return NULL;
   14920             : }
   14921             : 
   14922             : 
   14923           0 : SWIGINTERN PyObject *_wrap_labelObj_minfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14924             :   PyObject *resultobj = 0;
   14925             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14926             :   int arg2 ;
   14927           0 :   void *argp1 = 0 ;
   14928             :   int res1 = 0 ;
   14929             :   int val2 ;
   14930             :   int ecode2 = 0 ;
   14931           0 :   PyObject * obj0 = 0 ;
   14932           0 :   PyObject * obj1 = 0 ;
   14933             :   
   14934           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minfeaturesize_set",&obj0,&obj1)) SWIG_fail;
   14935           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14936           0 :   if (!SWIG_IsOK(res1)) {
   14937           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minfeaturesize_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14938             :   }
   14939           0 :   arg1 = (struct labelObj *)(argp1);
   14940           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14941           0 :   if (!SWIG_IsOK(ecode2)) {
   14942           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minfeaturesize_set" "', argument " "2"" of type '" "int""'");
   14943             :   } 
   14944             :   arg2 = (int)(val2);
   14945           0 :   if (arg1) (arg1)->minfeaturesize = arg2;
   14946             :   resultobj = SWIG_Py_Void();
   14947           0 :   return resultobj;
   14948           0 : fail:
   14949             :   return NULL;
   14950             : }
   14951             : 
   14952             : 
   14953           0 : SWIGINTERN PyObject *_wrap_labelObj_minfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14954             :   PyObject *resultobj = 0;
   14955             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14956           0 :   void *argp1 = 0 ;
   14957             :   int res1 = 0 ;
   14958           0 :   PyObject * obj0 = 0 ;
   14959             :   int result;
   14960             :   
   14961           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minfeaturesize_get",&obj0)) SWIG_fail;
   14962           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14963           0 :   if (!SWIG_IsOK(res1)) {
   14964           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minfeaturesize_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14965             :   }
   14966           0 :   arg1 = (struct labelObj *)(argp1);
   14967           0 :   result = (int) ((arg1)->minfeaturesize);
   14968             :   resultobj = SWIG_From_int((int)(result));
   14969           0 :   return resultobj;
   14970           0 : fail:
   14971             :   return NULL;
   14972             : }
   14973             : 
   14974             : 
   14975           0 : SWIGINTERN PyObject *_wrap_labelObj_autominfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   14976             :   PyObject *resultobj = 0;
   14977             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   14978             :   int arg2 ;
   14979           0 :   void *argp1 = 0 ;
   14980             :   int res1 = 0 ;
   14981             :   int val2 ;
   14982             :   int ecode2 = 0 ;
   14983           0 :   PyObject * obj0 = 0 ;
   14984           0 :   PyObject * obj1 = 0 ;
   14985             :   
   14986           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_autominfeaturesize_set",&obj0,&obj1)) SWIG_fail;
   14987           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   14988           0 :   if (!SWIG_IsOK(res1)) {
   14989           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_autominfeaturesize_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   14990             :   }
   14991           0 :   arg1 = (struct labelObj *)(argp1);
   14992           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   14993           0 :   if (!SWIG_IsOK(ecode2)) {
   14994           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_autominfeaturesize_set" "', argument " "2"" of type '" "int""'");
   14995             :   } 
   14996             :   arg2 = (int)(val2);
   14997           0 :   if (arg1) (arg1)->autominfeaturesize = arg2;
   14998             :   resultobj = SWIG_Py_Void();
   14999           0 :   return resultobj;
   15000           0 : fail:
   15001             :   return NULL;
   15002             : }
   15003             : 
   15004             : 
   15005           0 : SWIGINTERN PyObject *_wrap_labelObj_autominfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15006             :   PyObject *resultobj = 0;
   15007             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15008           0 :   void *argp1 = 0 ;
   15009             :   int res1 = 0 ;
   15010           0 :   PyObject * obj0 = 0 ;
   15011             :   int result;
   15012             :   
   15013           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_autominfeaturesize_get",&obj0)) SWIG_fail;
   15014           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15015           0 :   if (!SWIG_IsOK(res1)) {
   15016           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_autominfeaturesize_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15017             :   }
   15018           0 :   arg1 = (struct labelObj *)(argp1);
   15019           0 :   result = (int) ((arg1)->autominfeaturesize);
   15020             :   resultobj = SWIG_From_int((int)(result));
   15021           0 :   return resultobj;
   15022           0 : fail:
   15023             :   return NULL;
   15024             : }
   15025             : 
   15026             : 
   15027           0 : SWIGINTERN PyObject *_wrap_labelObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15028             :   PyObject *resultobj = 0;
   15029             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15030             :   double arg2 ;
   15031           0 :   void *argp1 = 0 ;
   15032             :   int res1 = 0 ;
   15033             :   double val2 ;
   15034             :   int ecode2 = 0 ;
   15035           0 :   PyObject * obj0 = 0 ;
   15036           0 :   PyObject * obj1 = 0 ;
   15037             :   
   15038           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
   15039           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15040           0 :   if (!SWIG_IsOK(res1)) {
   15041           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minscaledenom_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15042             :   }
   15043           0 :   arg1 = (struct labelObj *)(argp1);
   15044           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   15045           0 :   if (!SWIG_IsOK(ecode2)) {
   15046           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
   15047             :   } 
   15048           0 :   arg2 = (double)(val2);
   15049           0 :   if (arg1) (arg1)->minscaledenom = arg2;
   15050             :   resultobj = SWIG_Py_Void();
   15051           0 :   return resultobj;
   15052           0 : fail:
   15053             :   return NULL;
   15054             : }
   15055             : 
   15056             : 
   15057           0 : SWIGINTERN PyObject *_wrap_labelObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15058             :   PyObject *resultobj = 0;
   15059             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15060           0 :   void *argp1 = 0 ;
   15061             :   int res1 = 0 ;
   15062           0 :   PyObject * obj0 = 0 ;
   15063             :   double result;
   15064             :   
   15065           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minscaledenom_get",&obj0)) SWIG_fail;
   15066           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15067           0 :   if (!SWIG_IsOK(res1)) {
   15068           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minscaledenom_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15069             :   }
   15070           0 :   arg1 = (struct labelObj *)(argp1);
   15071           0 :   result = (double) ((arg1)->minscaledenom);
   15072           0 :   resultobj = SWIG_From_double((double)(result));
   15073           0 :   return resultobj;
   15074           0 : fail:
   15075             :   return NULL;
   15076             : }
   15077             : 
   15078             : 
   15079           0 : SWIGINTERN PyObject *_wrap_labelObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15080             :   PyObject *resultobj = 0;
   15081             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15082             :   double arg2 ;
   15083           0 :   void *argp1 = 0 ;
   15084             :   int res1 = 0 ;
   15085             :   double val2 ;
   15086             :   int ecode2 = 0 ;
   15087           0 :   PyObject * obj0 = 0 ;
   15088           0 :   PyObject * obj1 = 0 ;
   15089             :   
   15090           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
   15091           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15092           0 :   if (!SWIG_IsOK(res1)) {
   15093           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxscaledenom_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15094             :   }
   15095           0 :   arg1 = (struct labelObj *)(argp1);
   15096           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   15097           0 :   if (!SWIG_IsOK(ecode2)) {
   15098           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
   15099             :   } 
   15100           0 :   arg2 = (double)(val2);
   15101           0 :   if (arg1) (arg1)->maxscaledenom = arg2;
   15102             :   resultobj = SWIG_Py_Void();
   15103           0 :   return resultobj;
   15104           0 : fail:
   15105             :   return NULL;
   15106             : }
   15107             : 
   15108             : 
   15109           0 : SWIGINTERN PyObject *_wrap_labelObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15110             :   PyObject *resultobj = 0;
   15111             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15112           0 :   void *argp1 = 0 ;
   15113             :   int res1 = 0 ;
   15114           0 :   PyObject * obj0 = 0 ;
   15115             :   double result;
   15116             :   
   15117           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxscaledenom_get",&obj0)) SWIG_fail;
   15118           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15119           0 :   if (!SWIG_IsOK(res1)) {
   15120           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxscaledenom_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15121             :   }
   15122           0 :   arg1 = (struct labelObj *)(argp1);
   15123           0 :   result = (double) ((arg1)->maxscaledenom);
   15124           0 :   resultobj = SWIG_From_double((double)(result));
   15125           0 :   return resultobj;
   15126           0 : fail:
   15127             :   return NULL;
   15128             : }
   15129             : 
   15130             : 
   15131           0 : SWIGINTERN PyObject *_wrap_labelObj_mindistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15132             :   PyObject *resultobj = 0;
   15133             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15134             :   int arg2 ;
   15135           0 :   void *argp1 = 0 ;
   15136             :   int res1 = 0 ;
   15137             :   int val2 ;
   15138             :   int ecode2 = 0 ;
   15139           0 :   PyObject * obj0 = 0 ;
   15140           0 :   PyObject * obj1 = 0 ;
   15141             :   
   15142           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_mindistance_set",&obj0,&obj1)) SWIG_fail;
   15143           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15144           0 :   if (!SWIG_IsOK(res1)) {
   15145           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_mindistance_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15146             :   }
   15147           0 :   arg1 = (struct labelObj *)(argp1);
   15148           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15149           0 :   if (!SWIG_IsOK(ecode2)) {
   15150           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_mindistance_set" "', argument " "2"" of type '" "int""'");
   15151             :   } 
   15152             :   arg2 = (int)(val2);
   15153           0 :   if (arg1) (arg1)->mindistance = arg2;
   15154             :   resultobj = SWIG_Py_Void();
   15155           0 :   return resultobj;
   15156           0 : fail:
   15157             :   return NULL;
   15158             : }
   15159             : 
   15160             : 
   15161           0 : SWIGINTERN PyObject *_wrap_labelObj_mindistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15162             :   PyObject *resultobj = 0;
   15163             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15164           0 :   void *argp1 = 0 ;
   15165             :   int res1 = 0 ;
   15166           0 :   PyObject * obj0 = 0 ;
   15167             :   int result;
   15168             :   
   15169           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_mindistance_get",&obj0)) SWIG_fail;
   15170           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15171           0 :   if (!SWIG_IsOK(res1)) {
   15172           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_mindistance_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15173             :   }
   15174           0 :   arg1 = (struct labelObj *)(argp1);
   15175           0 :   result = (int) ((arg1)->mindistance);
   15176             :   resultobj = SWIG_From_int((int)(result));
   15177           0 :   return resultobj;
   15178           0 : fail:
   15179             :   return NULL;
   15180             : }
   15181             : 
   15182             : 
   15183           0 : SWIGINTERN PyObject *_wrap_labelObj_repeatdistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15184             :   PyObject *resultobj = 0;
   15185             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15186             :   int arg2 ;
   15187           0 :   void *argp1 = 0 ;
   15188             :   int res1 = 0 ;
   15189             :   int val2 ;
   15190             :   int ecode2 = 0 ;
   15191           0 :   PyObject * obj0 = 0 ;
   15192           0 :   PyObject * obj1 = 0 ;
   15193             :   
   15194           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_repeatdistance_set",&obj0,&obj1)) SWIG_fail;
   15195           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15196           0 :   if (!SWIG_IsOK(res1)) {
   15197           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_repeatdistance_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15198             :   }
   15199           0 :   arg1 = (struct labelObj *)(argp1);
   15200           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15201           0 :   if (!SWIG_IsOK(ecode2)) {
   15202           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_repeatdistance_set" "', argument " "2"" of type '" "int""'");
   15203             :   } 
   15204             :   arg2 = (int)(val2);
   15205           0 :   if (arg1) (arg1)->repeatdistance = arg2;
   15206             :   resultobj = SWIG_Py_Void();
   15207           0 :   return resultobj;
   15208           0 : fail:
   15209             :   return NULL;
   15210             : }
   15211             : 
   15212             : 
   15213           0 : SWIGINTERN PyObject *_wrap_labelObj_repeatdistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15214             :   PyObject *resultobj = 0;
   15215             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15216           0 :   void *argp1 = 0 ;
   15217             :   int res1 = 0 ;
   15218           0 :   PyObject * obj0 = 0 ;
   15219             :   int result;
   15220             :   
   15221           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_repeatdistance_get",&obj0)) SWIG_fail;
   15222           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15223           0 :   if (!SWIG_IsOK(res1)) {
   15224           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_repeatdistance_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15225             :   }
   15226           0 :   arg1 = (struct labelObj *)(argp1);
   15227           0 :   result = (int) ((arg1)->repeatdistance);
   15228             :   resultobj = SWIG_From_int((int)(result));
   15229           0 :   return resultobj;
   15230           0 : fail:
   15231             :   return NULL;
   15232             : }
   15233             : 
   15234             : 
   15235           0 : SWIGINTERN PyObject *_wrap_labelObj_maxoverlapangle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15236             :   PyObject *resultobj = 0;
   15237             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15238             :   double arg2 ;
   15239           0 :   void *argp1 = 0 ;
   15240             :   int res1 = 0 ;
   15241             :   double val2 ;
   15242             :   int ecode2 = 0 ;
   15243           0 :   PyObject * obj0 = 0 ;
   15244           0 :   PyObject * obj1 = 0 ;
   15245             :   
   15246           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxoverlapangle_set",&obj0,&obj1)) SWIG_fail;
   15247           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15248           0 :   if (!SWIG_IsOK(res1)) {
   15249           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxoverlapangle_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15250             :   }
   15251           0 :   arg1 = (struct labelObj *)(argp1);
   15252           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   15253           0 :   if (!SWIG_IsOK(ecode2)) {
   15254           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxoverlapangle_set" "', argument " "2"" of type '" "double""'");
   15255             :   } 
   15256           0 :   arg2 = (double)(val2);
   15257           0 :   if (arg1) (arg1)->maxoverlapangle = arg2;
   15258             :   resultobj = SWIG_Py_Void();
   15259           0 :   return resultobj;
   15260           0 : fail:
   15261             :   return NULL;
   15262             : }
   15263             : 
   15264             : 
   15265           0 : SWIGINTERN PyObject *_wrap_labelObj_maxoverlapangle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15266             :   PyObject *resultobj = 0;
   15267             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15268           0 :   void *argp1 = 0 ;
   15269             :   int res1 = 0 ;
   15270           0 :   PyObject * obj0 = 0 ;
   15271             :   double result;
   15272             :   
   15273           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxoverlapangle_get",&obj0)) SWIG_fail;
   15274           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15275           0 :   if (!SWIG_IsOK(res1)) {
   15276           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxoverlapangle_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15277             :   }
   15278           0 :   arg1 = (struct labelObj *)(argp1);
   15279           0 :   result = (double) ((arg1)->maxoverlapangle);
   15280           0 :   resultobj = SWIG_From_double((double)(result));
   15281           0 :   return resultobj;
   15282           0 : fail:
   15283             :   return NULL;
   15284             : }
   15285             : 
   15286             : 
   15287           0 : SWIGINTERN PyObject *_wrap_labelObj_partials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15288             :   PyObject *resultobj = 0;
   15289             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15290             :   int arg2 ;
   15291           0 :   void *argp1 = 0 ;
   15292             :   int res1 = 0 ;
   15293             :   int val2 ;
   15294             :   int ecode2 = 0 ;
   15295           0 :   PyObject * obj0 = 0 ;
   15296           0 :   PyObject * obj1 = 0 ;
   15297             :   
   15298           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_partials_set",&obj0,&obj1)) SWIG_fail;
   15299           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15300           0 :   if (!SWIG_IsOK(res1)) {
   15301           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_partials_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15302             :   }
   15303           0 :   arg1 = (struct labelObj *)(argp1);
   15304           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15305           0 :   if (!SWIG_IsOK(ecode2)) {
   15306           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_partials_set" "', argument " "2"" of type '" "int""'");
   15307             :   } 
   15308             :   arg2 = (int)(val2);
   15309           0 :   if (arg1) (arg1)->partials = arg2;
   15310             :   resultobj = SWIG_Py_Void();
   15311           0 :   return resultobj;
   15312           0 : fail:
   15313             :   return NULL;
   15314             : }
   15315             : 
   15316             : 
   15317           0 : SWIGINTERN PyObject *_wrap_labelObj_partials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15318             :   PyObject *resultobj = 0;
   15319             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15320           0 :   void *argp1 = 0 ;
   15321             :   int res1 = 0 ;
   15322           0 :   PyObject * obj0 = 0 ;
   15323             :   int result;
   15324             :   
   15325           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_partials_get",&obj0)) SWIG_fail;
   15326           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15327           0 :   if (!SWIG_IsOK(res1)) {
   15328           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_partials_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15329             :   }
   15330           0 :   arg1 = (struct labelObj *)(argp1);
   15331           0 :   result = (int) ((arg1)->partials);
   15332             :   resultobj = SWIG_From_int((int)(result));
   15333           0 :   return resultobj;
   15334           0 : fail:
   15335             :   return NULL;
   15336             : }
   15337             : 
   15338             : 
   15339           0 : SWIGINTERN PyObject *_wrap_labelObj_force_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15340             :   PyObject *resultobj = 0;
   15341             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15342             :   int arg2 ;
   15343           0 :   void *argp1 = 0 ;
   15344             :   int res1 = 0 ;
   15345             :   int val2 ;
   15346             :   int ecode2 = 0 ;
   15347           0 :   PyObject * obj0 = 0 ;
   15348           0 :   PyObject * obj1 = 0 ;
   15349             :   
   15350           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_force_set",&obj0,&obj1)) SWIG_fail;
   15351           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15352           0 :   if (!SWIG_IsOK(res1)) {
   15353           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_force_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15354             :   }
   15355           0 :   arg1 = (struct labelObj *)(argp1);
   15356           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15357           0 :   if (!SWIG_IsOK(ecode2)) {
   15358           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_force_set" "', argument " "2"" of type '" "int""'");
   15359             :   } 
   15360             :   arg2 = (int)(val2);
   15361           0 :   if (arg1) (arg1)->force = arg2;
   15362             :   resultobj = SWIG_Py_Void();
   15363           0 :   return resultobj;
   15364           0 : fail:
   15365             :   return NULL;
   15366             : }
   15367             : 
   15368             : 
   15369           0 : SWIGINTERN PyObject *_wrap_labelObj_force_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15370             :   PyObject *resultobj = 0;
   15371             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15372           0 :   void *argp1 = 0 ;
   15373             :   int res1 = 0 ;
   15374           0 :   PyObject * obj0 = 0 ;
   15375             :   int result;
   15376             :   
   15377           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_force_get",&obj0)) SWIG_fail;
   15378           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15379           0 :   if (!SWIG_IsOK(res1)) {
   15380           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_force_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15381             :   }
   15382           0 :   arg1 = (struct labelObj *)(argp1);
   15383           0 :   result = (int) ((arg1)->force);
   15384             :   resultobj = SWIG_From_int((int)(result));
   15385           0 :   return resultobj;
   15386           0 : fail:
   15387             :   return NULL;
   15388             : }
   15389             : 
   15390             : 
   15391           0 : SWIGINTERN PyObject *_wrap_labelObj_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15392             :   PyObject *resultobj = 0;
   15393             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15394             :   char *arg2 = (char *) 0 ;
   15395           0 :   void *argp1 = 0 ;
   15396             :   int res1 = 0 ;
   15397             :   int res2 ;
   15398           0 :   char *buf2 = 0 ;
   15399           0 :   int alloc2 = 0 ;
   15400           0 :   PyObject * obj0 = 0 ;
   15401           0 :   PyObject * obj1 = 0 ;
   15402             :   
   15403           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_encoding_set",&obj0,&obj1)) SWIG_fail;
   15404           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15405           0 :   if (!SWIG_IsOK(res1)) {
   15406           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_encoding_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15407             :   }
   15408           0 :   arg1 = (struct labelObj *)(argp1);
   15409           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   15410           0 :   if (!SWIG_IsOK(res2)) {
   15411           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_encoding_set" "', argument " "2"" of type '" "char *""'");
   15412             :   }
   15413           0 :   arg2 = (char *)(buf2);
   15414             :   {
   15415           0 :     if (arg1->encoding) free((char*)arg1->encoding);
   15416           0 :     if (arg2) {
   15417           0 :       arg1->encoding = (char *) malloc(strlen(arg2)+1);
   15418             :       strcpy((char*)arg1->encoding,arg2);
   15419             :     } else {
   15420           0 :       arg1->encoding = 0;
   15421             :     }
   15422             :   }
   15423             :   resultobj = SWIG_Py_Void();
   15424           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   15425             :   return resultobj;
   15426           0 : fail:
   15427           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   15428             :   return NULL;
   15429             : }
   15430             : 
   15431             : 
   15432           0 : SWIGINTERN PyObject *_wrap_labelObj_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15433             :   PyObject *resultobj = 0;
   15434             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15435           0 :   void *argp1 = 0 ;
   15436             :   int res1 = 0 ;
   15437           0 :   PyObject * obj0 = 0 ;
   15438             :   char *result = 0 ;
   15439             :   
   15440           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_encoding_get",&obj0)) SWIG_fail;
   15441           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15442           0 :   if (!SWIG_IsOK(res1)) {
   15443           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_encoding_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15444             :   }
   15445           0 :   arg1 = (struct labelObj *)(argp1);
   15446           0 :   result = (char *) ((arg1)->encoding);
   15447           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   15448           0 :   return resultobj;
   15449           0 : fail:
   15450             :   return NULL;
   15451             : }
   15452             : 
   15453             : 
   15454           0 : SWIGINTERN PyObject *_wrap_labelObj_priority_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15455             :   PyObject *resultobj = 0;
   15456             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15457             :   int arg2 ;
   15458           0 :   void *argp1 = 0 ;
   15459             :   int res1 = 0 ;
   15460             :   int val2 ;
   15461             :   int ecode2 = 0 ;
   15462           0 :   PyObject * obj0 = 0 ;
   15463           0 :   PyObject * obj1 = 0 ;
   15464             :   
   15465           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_priority_set",&obj0,&obj1)) SWIG_fail;
   15466           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15467           0 :   if (!SWIG_IsOK(res1)) {
   15468           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_priority_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15469             :   }
   15470           0 :   arg1 = (struct labelObj *)(argp1);
   15471           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15472           0 :   if (!SWIG_IsOK(ecode2)) {
   15473           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_priority_set" "', argument " "2"" of type '" "int""'");
   15474             :   } 
   15475             :   arg2 = (int)(val2);
   15476           0 :   if (arg1) (arg1)->priority = arg2;
   15477             :   resultobj = SWIG_Py_Void();
   15478           0 :   return resultobj;
   15479           0 : fail:
   15480             :   return NULL;
   15481             : }
   15482             : 
   15483             : 
   15484           0 : SWIGINTERN PyObject *_wrap_labelObj_priority_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15485             :   PyObject *resultobj = 0;
   15486             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15487           0 :   void *argp1 = 0 ;
   15488             :   int res1 = 0 ;
   15489           0 :   PyObject * obj0 = 0 ;
   15490             :   int result;
   15491             :   
   15492           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_priority_get",&obj0)) SWIG_fail;
   15493           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15494           0 :   if (!SWIG_IsOK(res1)) {
   15495           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_priority_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15496             :   }
   15497           0 :   arg1 = (struct labelObj *)(argp1);
   15498           0 :   result = (int) ((arg1)->priority);
   15499             :   resultobj = SWIG_From_int((int)(result));
   15500           0 :   return resultobj;
   15501           0 : fail:
   15502             :   return NULL;
   15503             : }
   15504             : 
   15505             : 
   15506           0 : SWIGINTERN PyObject *_wrap_labelObj_numstyles_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15507             :   PyObject *resultobj = 0;
   15508             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15509             :   int arg2 ;
   15510           0 :   void *argp1 = 0 ;
   15511             :   int res1 = 0 ;
   15512             :   int val2 ;
   15513             :   int ecode2 = 0 ;
   15514           0 :   PyObject * obj0 = 0 ;
   15515           0 :   PyObject * obj1 = 0 ;
   15516             :   
   15517           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_numstyles_set",&obj0,&obj1)) SWIG_fail;
   15518           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15519           0 :   if (!SWIG_IsOK(res1)) {
   15520           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_numstyles_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15521             :   }
   15522           0 :   arg1 = (struct labelObj *)(argp1);
   15523           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15524           0 :   if (!SWIG_IsOK(ecode2)) {
   15525           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_numstyles_set" "', argument " "2"" of type '" "int""'");
   15526             :   } 
   15527             :   arg2 = (int)(val2);
   15528           0 :   if (arg1) (arg1)->numstyles = arg2;
   15529             :   resultobj = SWIG_Py_Void();
   15530           0 :   return resultobj;
   15531           0 : fail:
   15532             :   return NULL;
   15533             : }
   15534             : 
   15535             : 
   15536           0 : SWIGINTERN PyObject *_wrap_labelObj_numstyles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15537             :   PyObject *resultobj = 0;
   15538             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15539           0 :   void *argp1 = 0 ;
   15540             :   int res1 = 0 ;
   15541           0 :   PyObject * obj0 = 0 ;
   15542             :   int result;
   15543             :   
   15544           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_numstyles_get",&obj0)) SWIG_fail;
   15545           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15546           0 :   if (!SWIG_IsOK(res1)) {
   15547           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_numstyles_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15548             :   }
   15549           0 :   arg1 = (struct labelObj *)(argp1);
   15550           0 :   result = (int) ((arg1)->numstyles);
   15551             :   resultobj = SWIG_From_int((int)(result));
   15552           0 :   return resultobj;
   15553           0 : fail:
   15554             :   return NULL;
   15555             : }
   15556             : 
   15557             : 
   15558           0 : SWIGINTERN PyObject *_wrap_labelObj_leader_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15559             :   PyObject *resultobj = 0;
   15560             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15561             :   labelLeaderObj *arg2 = (labelLeaderObj *) 0 ;
   15562           0 :   void *argp1 = 0 ;
   15563             :   int res1 = 0 ;
   15564           0 :   void *argp2 = 0 ;
   15565             :   int res2 = 0 ;
   15566           0 :   PyObject * obj0 = 0 ;
   15567           0 :   PyObject * obj1 = 0 ;
   15568             :   
   15569           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_leader_set",&obj0,&obj1)) SWIG_fail;
   15570           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15571           0 :   if (!SWIG_IsOK(res1)) {
   15572           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_leader_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15573             :   }
   15574           0 :   arg1 = (struct labelObj *)(argp1);
   15575           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_labelLeaderObj, SWIG_POINTER_DISOWN |  0 );
   15576           0 :   if (!SWIG_IsOK(res2)) {
   15577           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_leader_set" "', argument " "2"" of type '" "labelLeaderObj *""'"); 
   15578             :   }
   15579           0 :   arg2 = (labelLeaderObj *)(argp2);
   15580           0 :   if (arg1) (arg1)->leader = arg2;
   15581             :   resultobj = SWIG_Py_Void();
   15582           0 :   return resultobj;
   15583           0 : fail:
   15584             :   return NULL;
   15585             : }
   15586             : 
   15587             : 
   15588           0 : SWIGINTERN PyObject *_wrap_labelObj_leader_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15589             :   PyObject *resultobj = 0;
   15590             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15591           0 :   void *argp1 = 0 ;
   15592             :   int res1 = 0 ;
   15593           0 :   PyObject * obj0 = 0 ;
   15594             :   labelLeaderObj *result = 0 ;
   15595             :   
   15596           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_leader_get",&obj0)) SWIG_fail;
   15597           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15598           0 :   if (!SWIG_IsOK(res1)) {
   15599           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_leader_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15600             :   }
   15601           0 :   arg1 = (struct labelObj *)(argp1);
   15602           0 :   result = (labelLeaderObj *) ((arg1)->leader);
   15603           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   15604           0 :   return resultobj;
   15605           0 : fail:
   15606             :   return NULL;
   15607             : }
   15608             : 
   15609             : 
   15610           0 : SWIGINTERN PyObject *_wrap_labelObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15611             :   PyObject *resultobj = 0;
   15612             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15613             :   int arg2 ;
   15614           0 :   void *argp1 = 0 ;
   15615             :   int res1 = 0 ;
   15616             :   int val2 ;
   15617             :   int ecode2 = 0 ;
   15618           0 :   PyObject * obj0 = 0 ;
   15619           0 :   PyObject * obj1 = 0 ;
   15620             :   
   15621           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
   15622           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15623           0 :   if (!SWIG_IsOK(res1)) {
   15624           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_sizeunits_set" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15625             :   }
   15626           0 :   arg1 = (struct labelObj *)(argp1);
   15627           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15628           0 :   if (!SWIG_IsOK(ecode2)) {
   15629           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
   15630             :   } 
   15631             :   arg2 = (int)(val2);
   15632           0 :   if (arg1) (arg1)->sizeunits = arg2;
   15633             :   resultobj = SWIG_Py_Void();
   15634           0 :   return resultobj;
   15635           0 : fail:
   15636             :   return NULL;
   15637             : }
   15638             : 
   15639             : 
   15640           0 : SWIGINTERN PyObject *_wrap_labelObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15641             :   PyObject *resultobj = 0;
   15642             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15643           0 :   void *argp1 = 0 ;
   15644             :   int res1 = 0 ;
   15645           0 :   PyObject * obj0 = 0 ;
   15646             :   int result;
   15647             :   
   15648           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_sizeunits_get",&obj0)) SWIG_fail;
   15649           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15650           0 :   if (!SWIG_IsOK(res1)) {
   15651           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_sizeunits_get" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15652             :   }
   15653           0 :   arg1 = (struct labelObj *)(argp1);
   15654           0 :   result = (int) ((arg1)->sizeunits);
   15655             :   resultobj = SWIG_From_int((int)(result));
   15656           0 :   return resultobj;
   15657           0 : fail:
   15658             :   return NULL;
   15659             : }
   15660             : 
   15661             : 
   15662           1 : SWIGINTERN PyObject *_wrap_new_labelObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15663             :   PyObject *resultobj = 0;
   15664             :   struct labelObj *result = 0 ;
   15665             :   
   15666           1 :   if (!PyArg_ParseTuple(args,(char *)":new_labelObj")) SWIG_fail;
   15667             :   {
   15668           1 :     result = (struct labelObj *)new_labelObj(); {
   15669           1 :       errorObj *ms_error = msGetErrorObj();
   15670             :       
   15671           1 :       switch(ms_error->code) {
   15672             :       case MS_NOERR:
   15673             :         break;
   15674           0 :       case MS_NOTFOUND:
   15675           0 :         msResetErrorList();
   15676           0 :         break;
   15677             :       case -1:
   15678             :         break;
   15679           0 :       case MS_IOERR:
   15680           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   15681           0 :           _raise_ms_exception();
   15682           0 :           msResetErrorList();
   15683           0 :           return NULL;
   15684             :         }
   15685             :       default:
   15686           0 :         _raise_ms_exception();
   15687           0 :         msResetErrorList();
   15688           0 :         return NULL;
   15689             :       }
   15690             :       
   15691             :     }
   15692             :   }
   15693           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, SWIG_POINTER_NEW |  0 );
   15694           1 :   return resultobj;
   15695           1 : fail:
   15696             :   return NULL;
   15697             : }
   15698             : 
   15699             : 
   15700           1 : SWIGINTERN PyObject *_wrap_delete_labelObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15701             :   PyObject *resultobj = 0;
   15702             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15703           1 :   void *argp1 = 0 ;
   15704             :   int res1 = 0 ;
   15705           1 :   PyObject * obj0 = 0 ;
   15706             :   
   15707           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_labelObj",&obj0)) SWIG_fail;
   15708           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, SWIG_POINTER_DISOWN |  0 );
   15709           1 :   if (!SWIG_IsOK(res1)) {
   15710           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelObj" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15711             :   }
   15712           1 :   arg1 = (struct labelObj *)(argp1);
   15713             :   {
   15714             :     delete_labelObj(arg1); {
   15715           1 :       errorObj *ms_error = msGetErrorObj();
   15716             :       
   15717           1 :       switch(ms_error->code) {
   15718             :       case MS_NOERR:
   15719             :         break;
   15720           0 :       case MS_NOTFOUND:
   15721           0 :         msResetErrorList();
   15722           0 :         break;
   15723             :       case -1:
   15724             :         break;
   15725           0 :       case MS_IOERR:
   15726           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   15727           0 :           _raise_ms_exception();
   15728           0 :           msResetErrorList();
   15729           0 :           return NULL;
   15730             :         }
   15731             :       default:
   15732           0 :         _raise_ms_exception();
   15733           0 :         msResetErrorList();
   15734           0 :         return NULL;
   15735             :       }
   15736             :       
   15737             :     }
   15738             :   }
   15739             :   resultobj = SWIG_Py_Void();
   15740           1 :   return resultobj;
   15741           0 : fail:
   15742             :   return NULL;
   15743             : }
   15744             : 
   15745             : 
   15746           0 : SWIGINTERN PyObject *_wrap_labelObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15747             :   PyObject *resultobj = 0;
   15748             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15749             :   char *arg2 = (char *) 0 ;
   15750           0 :   void *argp1 = 0 ;
   15751             :   int res1 = 0 ;
   15752             :   int res2 ;
   15753           0 :   char *buf2 = 0 ;
   15754           0 :   int alloc2 = 0 ;
   15755           0 :   PyObject * obj0 = 0 ;
   15756           0 :   PyObject * obj1 = 0 ;
   15757             :   int result;
   15758             :   
   15759           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   15760           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15761           0 :   if (!SWIG_IsOK(res1)) {
   15762           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_updateFromString" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15763             :   }
   15764           0 :   arg1 = (struct labelObj *)(argp1);
   15765           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   15766           0 :   if (!SWIG_IsOK(res2)) {
   15767           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   15768             :   }
   15769           0 :   arg2 = (char *)(buf2);
   15770             :   {
   15771             :     result = (int)labelObj_updateFromString(arg1,arg2); {
   15772           0 :       errorObj *ms_error = msGetErrorObj();
   15773             :       
   15774           0 :       switch(ms_error->code) {
   15775             :       case MS_NOERR:
   15776             :         break;
   15777           0 :       case MS_NOTFOUND:
   15778           0 :         msResetErrorList();
   15779           0 :         break;
   15780             :       case -1:
   15781             :         break;
   15782           0 :       case MS_IOERR:
   15783           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   15784           0 :           _raise_ms_exception();
   15785           0 :           msResetErrorList();
   15786           0 :           return NULL;
   15787             :         }
   15788             :       default:
   15789           0 :         _raise_ms_exception();
   15790           0 :         msResetErrorList();
   15791           0 :         return NULL;
   15792             :       }
   15793             :       
   15794             :     }
   15795             :   }
   15796             :   resultobj = SWIG_From_int((int)(result));
   15797           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   15798             :   return resultobj;
   15799           0 : fail:
   15800           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   15801             :   return NULL;
   15802             : }
   15803             : 
   15804             : 
   15805           0 : SWIGINTERN PyObject *_wrap_labelObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15806             :   PyObject *resultobj = 0;
   15807             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15808           0 :   void *argp1 = 0 ;
   15809             :   int res1 = 0 ;
   15810           0 :   PyObject * obj0 = 0 ;
   15811             :   char *result = 0 ;
   15812             :   
   15813           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_convertToString",&obj0)) SWIG_fail;
   15814           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15815           0 :   if (!SWIG_IsOK(res1)) {
   15816           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_convertToString" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15817             :   }
   15818           0 :   arg1 = (struct labelObj *)(argp1);
   15819             :   {
   15820             :     result = (char *)labelObj_convertToString(arg1); {
   15821           0 :       errorObj *ms_error = msGetErrorObj();
   15822             :       
   15823           0 :       switch(ms_error->code) {
   15824             :       case MS_NOERR:
   15825             :         break;
   15826           0 :       case MS_NOTFOUND:
   15827           0 :         msResetErrorList();
   15828           0 :         break;
   15829             :       case -1:
   15830             :         break;
   15831           0 :       case MS_IOERR:
   15832           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   15833           0 :           _raise_ms_exception();
   15834           0 :           msResetErrorList();
   15835           0 :           return NULL;
   15836             :         }
   15837             :       default:
   15838           0 :         _raise_ms_exception();
   15839           0 :         msResetErrorList();
   15840           0 :         return NULL;
   15841             :       }
   15842             :       
   15843             :     }
   15844             :   }
   15845           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   15846           0 :   free((char*)result);
   15847           0 :   return resultobj;
   15848           0 : fail:
   15849             :   return NULL;
   15850             : }
   15851             : 
   15852             : 
   15853           0 : SWIGINTERN PyObject *_wrap_labelObj_removeBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15854             :   PyObject *resultobj = 0;
   15855             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15856             :   int arg2 ;
   15857           0 :   void *argp1 = 0 ;
   15858             :   int res1 = 0 ;
   15859             :   int val2 ;
   15860             :   int ecode2 = 0 ;
   15861           0 :   PyObject * obj0 = 0 ;
   15862           0 :   PyObject * obj1 = 0 ;
   15863             :   int result;
   15864             :   
   15865           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_removeBinding",&obj0,&obj1)) SWIG_fail;
   15866           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15867           0 :   if (!SWIG_IsOK(res1)) {
   15868           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_removeBinding" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15869             :   }
   15870           0 :   arg1 = (struct labelObj *)(argp1);
   15871           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15872           0 :   if (!SWIG_IsOK(ecode2)) {
   15873           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_removeBinding" "', argument " "2"" of type '" "int""'");
   15874             :   } 
   15875             :   arg2 = (int)(val2);
   15876             :   {
   15877             :     result = (int)labelObj_removeBinding(arg1,arg2); {
   15878           0 :       errorObj *ms_error = msGetErrorObj();
   15879             :       
   15880           0 :       switch(ms_error->code) {
   15881             :       case MS_NOERR:
   15882             :         break;
   15883           0 :       case MS_NOTFOUND:
   15884           0 :         msResetErrorList();
   15885           0 :         break;
   15886             :       case -1:
   15887             :         break;
   15888           0 :       case MS_IOERR:
   15889           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   15890           0 :           _raise_ms_exception();
   15891           0 :           msResetErrorList();
   15892           0 :           return NULL;
   15893             :         }
   15894             :       default:
   15895           0 :         _raise_ms_exception();
   15896           0 :         msResetErrorList();
   15897           0 :         return NULL;
   15898             :       }
   15899             :       
   15900             :     }
   15901             :   }
   15902             :   resultobj = SWIG_From_int((int)(result));
   15903           0 :   return resultobj;
   15904           0 : fail:
   15905             :   return NULL;
   15906             : }
   15907             : 
   15908             : 
   15909           1 : SWIGINTERN PyObject *_wrap_labelObj_getBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15910             :   PyObject *resultobj = 0;
   15911             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15912             :   int arg2 ;
   15913           1 :   void *argp1 = 0 ;
   15914             :   int res1 = 0 ;
   15915             :   int val2 ;
   15916             :   int ecode2 = 0 ;
   15917           1 :   PyObject * obj0 = 0 ;
   15918           1 :   PyObject * obj1 = 0 ;
   15919             :   char *result = 0 ;
   15920             :   
   15921           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_getBinding",&obj0,&obj1)) SWIG_fail;
   15922           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15923           1 :   if (!SWIG_IsOK(res1)) {
   15924           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getBinding" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15925             :   }
   15926           1 :   arg1 = (struct labelObj *)(argp1);
   15927           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15928           1 :   if (!SWIG_IsOK(ecode2)) {
   15929           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_getBinding" "', argument " "2"" of type '" "int""'");
   15930             :   } 
   15931             :   arg2 = (int)(val2);
   15932             :   {
   15933             :     result = (char *)labelObj_getBinding(arg1,arg2); {
   15934           1 :       errorObj *ms_error = msGetErrorObj();
   15935             :       
   15936           1 :       switch(ms_error->code) {
   15937             :       case MS_NOERR:
   15938             :         break;
   15939           0 :       case MS_NOTFOUND:
   15940           0 :         msResetErrorList();
   15941           0 :         break;
   15942             :       case -1:
   15943             :         break;
   15944           0 :       case MS_IOERR:
   15945           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   15946           0 :           _raise_ms_exception();
   15947           0 :           msResetErrorList();
   15948           0 :           return NULL;
   15949             :         }
   15950             :       default:
   15951           0 :         _raise_ms_exception();
   15952           0 :         msResetErrorList();
   15953           0 :         return NULL;
   15954             :       }
   15955             :       
   15956             :     }
   15957             :   }
   15958           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   15959           1 :   return resultobj;
   15960           0 : fail:
   15961             :   return NULL;
   15962             : }
   15963             : 
   15964             : 
   15965           1 : SWIGINTERN PyObject *_wrap_labelObj_setBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   15966             :   PyObject *resultobj = 0;
   15967             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   15968             :   int arg2 ;
   15969             :   char *arg3 = (char *) 0 ;
   15970           1 :   void *argp1 = 0 ;
   15971             :   int res1 = 0 ;
   15972             :   int val2 ;
   15973             :   int ecode2 = 0 ;
   15974             :   int res3 ;
   15975           1 :   char *buf3 = 0 ;
   15976           1 :   int alloc3 = 0 ;
   15977           1 :   PyObject * obj0 = 0 ;
   15978           1 :   PyObject * obj1 = 0 ;
   15979           1 :   PyObject * obj2 = 0 ;
   15980             :   int result;
   15981             :   
   15982           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:labelObj_setBinding",&obj0,&obj1,&obj2)) SWIG_fail;
   15983           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   15984           1 :   if (!SWIG_IsOK(res1)) {
   15985           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_setBinding" "', argument " "1"" of type '" "struct labelObj *""'"); 
   15986             :   }
   15987           1 :   arg1 = (struct labelObj *)(argp1);
   15988           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   15989           1 :   if (!SWIG_IsOK(ecode2)) {
   15990           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_setBinding" "', argument " "2"" of type '" "int""'");
   15991             :   } 
   15992             :   arg2 = (int)(val2);
   15993           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   15994           1 :   if (!SWIG_IsOK(res3)) {
   15995           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "labelObj_setBinding" "', argument " "3"" of type '" "char *""'");
   15996             :   }
   15997           1 :   arg3 = (char *)(buf3);
   15998             :   {
   15999           1 :     result = (int)labelObj_setBinding(arg1,arg2,arg3); {
   16000           1 :       errorObj *ms_error = msGetErrorObj();
   16001             :       
   16002           1 :       switch(ms_error->code) {
   16003             :       case MS_NOERR:
   16004             :         break;
   16005           0 :       case MS_NOTFOUND:
   16006           0 :         msResetErrorList();
   16007           0 :         break;
   16008             :       case -1:
   16009             :         break;
   16010           0 :       case MS_IOERR:
   16011           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16012           0 :           _raise_ms_exception();
   16013           0 :           msResetErrorList();
   16014           0 :           return NULL;
   16015             :         }
   16016             :       default:
   16017           0 :         _raise_ms_exception();
   16018           0 :         msResetErrorList();
   16019           0 :         return NULL;
   16020             :       }
   16021             :       
   16022             :     }
   16023             :   }
   16024             :   resultobj = SWIG_From_int((int)(result));
   16025           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   16026             :   return resultobj;
   16027           0 : fail:
   16028           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   16029             :   return NULL;
   16030             : }
   16031             : 
   16032             : 
   16033           0 : SWIGINTERN PyObject *_wrap_labelObj_setExpression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16034             :   PyObject *resultobj = 0;
   16035             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16036             :   char *arg2 = (char *) 0 ;
   16037           0 :   void *argp1 = 0 ;
   16038             :   int res1 = 0 ;
   16039             :   int res2 ;
   16040           0 :   char *buf2 = 0 ;
   16041           0 :   int alloc2 = 0 ;
   16042           0 :   PyObject * obj0 = 0 ;
   16043           0 :   PyObject * obj1 = 0 ;
   16044             :   int result;
   16045             :   
   16046           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_setExpression",&obj0,&obj1)) SWIG_fail;
   16047           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16048           0 :   if (!SWIG_IsOK(res1)) {
   16049           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_setExpression" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16050             :   }
   16051           0 :   arg1 = (struct labelObj *)(argp1);
   16052           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   16053           0 :   if (!SWIG_IsOK(res2)) {
   16054           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_setExpression" "', argument " "2"" of type '" "char *""'");
   16055             :   }
   16056           0 :   arg2 = (char *)(buf2);
   16057             :   {
   16058           0 :     result = (int)labelObj_setExpression(arg1,arg2); {
   16059           0 :       errorObj *ms_error = msGetErrorObj();
   16060             :       
   16061           0 :       switch(ms_error->code) {
   16062             :       case MS_NOERR:
   16063             :         break;
   16064           0 :       case MS_NOTFOUND:
   16065           0 :         msResetErrorList();
   16066           0 :         break;
   16067             :       case -1:
   16068             :         break;
   16069           0 :       case MS_IOERR:
   16070           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16071           0 :           _raise_ms_exception();
   16072           0 :           msResetErrorList();
   16073           0 :           return NULL;
   16074             :         }
   16075             :       default:
   16076           0 :         _raise_ms_exception();
   16077           0 :         msResetErrorList();
   16078           0 :         return NULL;
   16079             :       }
   16080             :       
   16081             :     }
   16082             :   }
   16083             :   resultobj = SWIG_From_int((int)(result));
   16084           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16085             :   return resultobj;
   16086           0 : fail:
   16087           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16088             :   return NULL;
   16089             : }
   16090             : 
   16091             : 
   16092           0 : SWIGINTERN PyObject *_wrap_labelObj_getExpressionString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16093             :   PyObject *resultobj = 0;
   16094             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16095           0 :   void *argp1 = 0 ;
   16096             :   int res1 = 0 ;
   16097           0 :   PyObject * obj0 = 0 ;
   16098             :   char *result = 0 ;
   16099             :   
   16100           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_getExpressionString",&obj0)) SWIG_fail;
   16101           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16102           0 :   if (!SWIG_IsOK(res1)) {
   16103           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getExpressionString" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16104             :   }
   16105           0 :   arg1 = (struct labelObj *)(argp1);
   16106             :   {
   16107             :     result = (char *)labelObj_getExpressionString(arg1); {
   16108           0 :       errorObj *ms_error = msGetErrorObj();
   16109             :       
   16110           0 :       switch(ms_error->code) {
   16111             :       case MS_NOERR:
   16112             :         break;
   16113           0 :       case MS_NOTFOUND:
   16114           0 :         msResetErrorList();
   16115           0 :         break;
   16116             :       case -1:
   16117             :         break;
   16118           0 :       case MS_IOERR:
   16119           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16120           0 :           _raise_ms_exception();
   16121           0 :           msResetErrorList();
   16122           0 :           return NULL;
   16123             :         }
   16124             :       default:
   16125           0 :         _raise_ms_exception();
   16126           0 :         msResetErrorList();
   16127           0 :         return NULL;
   16128             :       }
   16129             :       
   16130             :     }
   16131             :   }
   16132           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   16133           0 :   free((char*)result);
   16134           0 :   return resultobj;
   16135           0 : fail:
   16136             :   return NULL;
   16137             : }
   16138             : 
   16139             : 
   16140           0 : SWIGINTERN PyObject *_wrap_labelObj_setText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16141             :   PyObject *resultobj = 0;
   16142             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16143             :   char *arg2 = (char *) 0 ;
   16144           0 :   void *argp1 = 0 ;
   16145             :   int res1 = 0 ;
   16146             :   int res2 ;
   16147           0 :   char *buf2 = 0 ;
   16148           0 :   int alloc2 = 0 ;
   16149           0 :   PyObject * obj0 = 0 ;
   16150           0 :   PyObject * obj1 = 0 ;
   16151             :   int result;
   16152             :   
   16153           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_setText",&obj0,&obj1)) SWIG_fail;
   16154           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16155           0 :   if (!SWIG_IsOK(res1)) {
   16156           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_setText" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16157             :   }
   16158           0 :   arg1 = (struct labelObj *)(argp1);
   16159           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   16160           0 :   if (!SWIG_IsOK(res2)) {
   16161           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_setText" "', argument " "2"" of type '" "char *""'");
   16162             :   }
   16163           0 :   arg2 = (char *)(buf2);
   16164             :   {
   16165           0 :     result = (int)labelObj_setText(arg1,arg2); {
   16166           0 :       errorObj *ms_error = msGetErrorObj();
   16167             :       
   16168           0 :       switch(ms_error->code) {
   16169             :       case MS_NOERR:
   16170             :         break;
   16171           0 :       case MS_NOTFOUND:
   16172           0 :         msResetErrorList();
   16173           0 :         break;
   16174             :       case -1:
   16175             :         break;
   16176           0 :       case MS_IOERR:
   16177           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16178           0 :           _raise_ms_exception();
   16179           0 :           msResetErrorList();
   16180           0 :           return NULL;
   16181             :         }
   16182             :       default:
   16183           0 :         _raise_ms_exception();
   16184           0 :         msResetErrorList();
   16185           0 :         return NULL;
   16186             :       }
   16187             :       
   16188             :     }
   16189             :   }
   16190             :   resultobj = SWIG_From_int((int)(result));
   16191           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16192             :   return resultobj;
   16193           0 : fail:
   16194           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16195             :   return NULL;
   16196             : }
   16197             : 
   16198             : 
   16199           0 : SWIGINTERN PyObject *_wrap_labelObj_getTextString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16200             :   PyObject *resultobj = 0;
   16201             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16202           0 :   void *argp1 = 0 ;
   16203             :   int res1 = 0 ;
   16204           0 :   PyObject * obj0 = 0 ;
   16205             :   char *result = 0 ;
   16206             :   
   16207           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelObj_getTextString",&obj0)) SWIG_fail;
   16208           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16209           0 :   if (!SWIG_IsOK(res1)) {
   16210           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getTextString" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16211             :   }
   16212           0 :   arg1 = (struct labelObj *)(argp1);
   16213             :   {
   16214             :     result = (char *)labelObj_getTextString(arg1); {
   16215           0 :       errorObj *ms_error = msGetErrorObj();
   16216             :       
   16217           0 :       switch(ms_error->code) {
   16218             :       case MS_NOERR:
   16219             :         break;
   16220           0 :       case MS_NOTFOUND:
   16221           0 :         msResetErrorList();
   16222           0 :         break;
   16223             :       case -1:
   16224             :         break;
   16225           0 :       case MS_IOERR:
   16226           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16227           0 :           _raise_ms_exception();
   16228           0 :           msResetErrorList();
   16229           0 :           return NULL;
   16230             :         }
   16231             :       default:
   16232           0 :         _raise_ms_exception();
   16233           0 :         msResetErrorList();
   16234           0 :         return NULL;
   16235             :       }
   16236             :       
   16237             :     }
   16238             :   }
   16239           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   16240           0 :   free((char*)result);
   16241           0 :   return resultobj;
   16242           0 : fail:
   16243             :   return NULL;
   16244             : }
   16245             : 
   16246             : 
   16247           0 : SWIGINTERN PyObject *_wrap_labelObj_getStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16248             :   PyObject *resultobj = 0;
   16249             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16250             :   int arg2 ;
   16251           0 :   void *argp1 = 0 ;
   16252             :   int res1 = 0 ;
   16253             :   int val2 ;
   16254             :   int ecode2 = 0 ;
   16255           0 :   PyObject * obj0 = 0 ;
   16256           0 :   PyObject * obj1 = 0 ;
   16257             :   styleObj *result = 0 ;
   16258             :   
   16259           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_getStyle",&obj0,&obj1)) SWIG_fail;
   16260           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16261           0 :   if (!SWIG_IsOK(res1)) {
   16262           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getStyle" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16263             :   }
   16264           0 :   arg1 = (struct labelObj *)(argp1);
   16265           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   16266           0 :   if (!SWIG_IsOK(ecode2)) {
   16267           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_getStyle" "', argument " "2"" of type '" "int""'");
   16268             :   } 
   16269             :   arg2 = (int)(val2);
   16270             :   {
   16271           0 :     result = (styleObj *)labelObj_getStyle(arg1,arg2); {
   16272           0 :       errorObj *ms_error = msGetErrorObj();
   16273             :       
   16274           0 :       switch(ms_error->code) {
   16275             :       case MS_NOERR:
   16276             :         break;
   16277           0 :       case MS_NOTFOUND:
   16278           0 :         msResetErrorList();
   16279           0 :         break;
   16280             :       case -1:
   16281             :         break;
   16282           0 :       case MS_IOERR:
   16283           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16284           0 :           _raise_ms_exception();
   16285           0 :           msResetErrorList();
   16286           0 :           return NULL;
   16287             :         }
   16288             :       default:
   16289           0 :         _raise_ms_exception();
   16290           0 :         msResetErrorList();
   16291           0 :         return NULL;
   16292             :       }
   16293             :       
   16294             :     }
   16295             :   }
   16296           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN |  0 );
   16297           0 :   return resultobj;
   16298           0 : fail:
   16299             :   return NULL;
   16300             : }
   16301             : 
   16302             : 
   16303           0 : SWIGINTERN PyObject *_wrap_labelObj_insertStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16304             :   PyObject *resultobj = 0;
   16305             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16306             :   styleObj *arg2 = (styleObj *) 0 ;
   16307             :   int arg3 = (int) -1 ;
   16308           0 :   void *argp1 = 0 ;
   16309             :   int res1 = 0 ;
   16310           0 :   void *argp2 = 0 ;
   16311             :   int res2 = 0 ;
   16312             :   int val3 ;
   16313             :   int ecode3 = 0 ;
   16314           0 :   PyObject * obj0 = 0 ;
   16315           0 :   PyObject * obj1 = 0 ;
   16316           0 :   PyObject * obj2 = 0 ;
   16317             :   int result;
   16318             :   
   16319           0 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:labelObj_insertStyle",&obj0,&obj1,&obj2)) SWIG_fail;
   16320           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16321           0 :   if (!SWIG_IsOK(res1)) {
   16322           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_insertStyle" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16323             :   }
   16324           0 :   arg1 = (struct labelObj *)(argp1);
   16325           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_styleObj, 0 |  0 );
   16326           0 :   if (!SWIG_IsOK(res2)) {
   16327           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_insertStyle" "', argument " "2"" of type '" "styleObj *""'"); 
   16328             :   }
   16329           0 :   arg2 = (styleObj *)(argp2);
   16330           0 :   if (obj2) {
   16331             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   16332           0 :     if (!SWIG_IsOK(ecode3)) {
   16333           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "labelObj_insertStyle" "', argument " "3"" of type '" "int""'");
   16334             :     } 
   16335             :     arg3 = (int)(val3);
   16336             :   }
   16337             :   {
   16338             :     result = (int)labelObj_insertStyle(arg1,arg2,arg3); {
   16339           0 :       errorObj *ms_error = msGetErrorObj();
   16340             :       
   16341           0 :       switch(ms_error->code) {
   16342             :       case MS_NOERR:
   16343             :         break;
   16344           0 :       case MS_NOTFOUND:
   16345           0 :         msResetErrorList();
   16346           0 :         break;
   16347             :       case -1:
   16348             :         break;
   16349           0 :       case MS_IOERR:
   16350           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16351           0 :           _raise_ms_exception();
   16352           0 :           msResetErrorList();
   16353           0 :           return NULL;
   16354             :         }
   16355             :       default:
   16356           0 :         _raise_ms_exception();
   16357           0 :         msResetErrorList();
   16358           0 :         return NULL;
   16359             :       }
   16360             :       
   16361             :     }
   16362             :   }
   16363             :   resultobj = SWIG_From_int((int)(result));
   16364           0 :   return resultobj;
   16365           0 : fail:
   16366             :   return NULL;
   16367             : }
   16368             : 
   16369             : 
   16370           0 : SWIGINTERN PyObject *_wrap_labelObj_removeStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16371             :   PyObject *resultobj = 0;
   16372             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16373             :   int arg2 ;
   16374           0 :   void *argp1 = 0 ;
   16375             :   int res1 = 0 ;
   16376             :   int val2 ;
   16377             :   int ecode2 = 0 ;
   16378           0 :   PyObject * obj0 = 0 ;
   16379           0 :   PyObject * obj1 = 0 ;
   16380             :   styleObj *result = 0 ;
   16381             :   
   16382           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_removeStyle",&obj0,&obj1)) SWIG_fail;
   16383           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16384           0 :   if (!SWIG_IsOK(res1)) {
   16385           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_removeStyle" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16386             :   }
   16387           0 :   arg1 = (struct labelObj *)(argp1);
   16388           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   16389           0 :   if (!SWIG_IsOK(ecode2)) {
   16390           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_removeStyle" "', argument " "2"" of type '" "int""'");
   16391             :   } 
   16392             :   arg2 = (int)(val2);
   16393             :   {
   16394           0 :     result = (styleObj *)labelObj_removeStyle(arg1,arg2); {
   16395           0 :       errorObj *ms_error = msGetErrorObj();
   16396             :       
   16397           0 :       switch(ms_error->code) {
   16398             :       case MS_NOERR:
   16399             :         break;
   16400           0 :       case MS_NOTFOUND:
   16401           0 :         msResetErrorList();
   16402           0 :         break;
   16403             :       case -1:
   16404             :         break;
   16405           0 :       case MS_IOERR:
   16406           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16407           0 :           _raise_ms_exception();
   16408           0 :           msResetErrorList();
   16409           0 :           return NULL;
   16410             :         }
   16411             :       default:
   16412           0 :         _raise_ms_exception();
   16413           0 :         msResetErrorList();
   16414           0 :         return NULL;
   16415             :       }
   16416             :       
   16417             :     }
   16418             :   }
   16419           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN |  0 );
   16420           0 :   return resultobj;
   16421           0 : fail:
   16422             :   return NULL;
   16423             : }
   16424             : 
   16425             : 
   16426           0 : SWIGINTERN PyObject *_wrap_labelObj_moveStyleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16427             :   PyObject *resultobj = 0;
   16428             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16429             :   int arg2 ;
   16430           0 :   void *argp1 = 0 ;
   16431             :   int res1 = 0 ;
   16432             :   int val2 ;
   16433             :   int ecode2 = 0 ;
   16434           0 :   PyObject * obj0 = 0 ;
   16435           0 :   PyObject * obj1 = 0 ;
   16436             :   int result;
   16437             :   
   16438           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_moveStyleUp",&obj0,&obj1)) SWIG_fail;
   16439           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16440           0 :   if (!SWIG_IsOK(res1)) {
   16441           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_moveStyleUp" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16442             :   }
   16443           0 :   arg1 = (struct labelObj *)(argp1);
   16444           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   16445           0 :   if (!SWIG_IsOK(ecode2)) {
   16446           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_moveStyleUp" "', argument " "2"" of type '" "int""'");
   16447             :   } 
   16448             :   arg2 = (int)(val2);
   16449             :   {
   16450             :     result = (int)labelObj_moveStyleUp(arg1,arg2); {
   16451           0 :       errorObj *ms_error = msGetErrorObj();
   16452             :       
   16453           0 :       switch(ms_error->code) {
   16454             :       case MS_NOERR:
   16455             :         break;
   16456           0 :       case MS_NOTFOUND:
   16457           0 :         msResetErrorList();
   16458           0 :         break;
   16459             :       case -1:
   16460             :         break;
   16461           0 :       case MS_IOERR:
   16462           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16463           0 :           _raise_ms_exception();
   16464           0 :           msResetErrorList();
   16465           0 :           return NULL;
   16466             :         }
   16467             :       default:
   16468           0 :         _raise_ms_exception();
   16469           0 :         msResetErrorList();
   16470           0 :         return NULL;
   16471             :       }
   16472             :       
   16473             :     }
   16474             :   }
   16475             :   resultobj = SWIG_From_int((int)(result));
   16476           0 :   return resultobj;
   16477           0 : fail:
   16478             :   return NULL;
   16479             : }
   16480             : 
   16481             : 
   16482           0 : SWIGINTERN PyObject *_wrap_labelObj_moveStyleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16483             :   PyObject *resultobj = 0;
   16484             :   struct labelObj *arg1 = (struct labelObj *) 0 ;
   16485             :   int arg2 ;
   16486           0 :   void *argp1 = 0 ;
   16487             :   int res1 = 0 ;
   16488             :   int val2 ;
   16489             :   int ecode2 = 0 ;
   16490           0 :   PyObject * obj0 = 0 ;
   16491           0 :   PyObject * obj1 = 0 ;
   16492             :   int result;
   16493             :   
   16494           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_moveStyleDown",&obj0,&obj1)) SWIG_fail;
   16495           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 |  0 );
   16496           0 :   if (!SWIG_IsOK(res1)) {
   16497           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_moveStyleDown" "', argument " "1"" of type '" "struct labelObj *""'"); 
   16498             :   }
   16499           0 :   arg1 = (struct labelObj *)(argp1);
   16500           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   16501           0 :   if (!SWIG_IsOK(ecode2)) {
   16502           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_moveStyleDown" "', argument " "2"" of type '" "int""'");
   16503             :   } 
   16504             :   arg2 = (int)(val2);
   16505             :   {
   16506             :     result = (int)labelObj_moveStyleDown(arg1,arg2); {
   16507           0 :       errorObj *ms_error = msGetErrorObj();
   16508             :       
   16509           0 :       switch(ms_error->code) {
   16510             :       case MS_NOERR:
   16511             :         break;
   16512           0 :       case MS_NOTFOUND:
   16513           0 :         msResetErrorList();
   16514           0 :         break;
   16515             :       case -1:
   16516             :         break;
   16517           0 :       case MS_IOERR:
   16518           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   16519           0 :           _raise_ms_exception();
   16520           0 :           msResetErrorList();
   16521           0 :           return NULL;
   16522             :         }
   16523             :       default:
   16524           0 :         _raise_ms_exception();
   16525           0 :         msResetErrorList();
   16526           0 :         return NULL;
   16527             :       }
   16528             :       
   16529             :     }
   16530             :   }
   16531             :   resultobj = SWIG_From_int((int)(result));
   16532           0 :   return resultobj;
   16533           0 : fail:
   16534             :   return NULL;
   16535             : }
   16536             : 
   16537             : 
   16538           1 : SWIGINTERN PyObject *labelObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16539             :   PyObject *obj;
   16540           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   16541           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_labelObj, SWIG_NewClientData(obj));
   16542           1 :   return SWIG_Py_Void();
   16543             : }
   16544             : 
   16545           1 : SWIGINTERN PyObject *_wrap_classObj_metadata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16546             :   PyObject *resultobj = 0;
   16547             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16548           1 :   void *argp1 = 0 ;
   16549             :   int res1 = 0 ;
   16550           1 :   PyObject * obj0 = 0 ;
   16551             :   hashTableObj *result = 0 ;
   16552             :   
   16553           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_metadata_get",&obj0)) SWIG_fail;
   16554           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16555           1 :   if (!SWIG_IsOK(res1)) {
   16556           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_metadata_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16557             :   }
   16558           1 :   arg1 = (struct classObj *)(argp1);
   16559           1 :   result = (hashTableObj *)& ((arg1)->metadata);
   16560           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   16561           1 :   return resultobj;
   16562           0 : fail:
   16563             :   return NULL;
   16564             : }
   16565             : 
   16566             : 
   16567           0 : SWIGINTERN PyObject *_wrap_classObj_validation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16568             :   PyObject *resultobj = 0;
   16569             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16570           0 :   void *argp1 = 0 ;
   16571             :   int res1 = 0 ;
   16572           0 :   PyObject * obj0 = 0 ;
   16573             :   hashTableObj *result = 0 ;
   16574             :   
   16575           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_validation_get",&obj0)) SWIG_fail;
   16576           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16577           0 :   if (!SWIG_IsOK(res1)) {
   16578           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_validation_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16579             :   }
   16580           0 :   arg1 = (struct classObj *)(argp1);
   16581           0 :   result = (hashTableObj *)& ((arg1)->validation);
   16582           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   16583           0 :   return resultobj;
   16584           0 : fail:
   16585             :   return NULL;
   16586             : }
   16587             : 
   16588             : 
   16589           1 : SWIGINTERN PyObject *_wrap_classObj_numstyles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16590             :   PyObject *resultobj = 0;
   16591             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16592           1 :   void *argp1 = 0 ;
   16593             :   int res1 = 0 ;
   16594           1 :   PyObject * obj0 = 0 ;
   16595             :   int result;
   16596             :   
   16597           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_numstyles_get",&obj0)) SWIG_fail;
   16598           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16599           1 :   if (!SWIG_IsOK(res1)) {
   16600           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_numstyles_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16601             :   }
   16602           1 :   arg1 = (struct classObj *)(argp1);
   16603           1 :   result = (int) ((arg1)->numstyles);
   16604             :   resultobj = SWIG_From_int((int)(result));
   16605           1 :   return resultobj;
   16606           0 : fail:
   16607             :   return NULL;
   16608             : }
   16609             : 
   16610             : 
   16611           0 : SWIGINTERN PyObject *_wrap_classObj_numlabels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16612             :   PyObject *resultobj = 0;
   16613             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16614           0 :   void *argp1 = 0 ;
   16615             :   int res1 = 0 ;
   16616           0 :   PyObject * obj0 = 0 ;
   16617             :   int result;
   16618             :   
   16619           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_numlabels_get",&obj0)) SWIG_fail;
   16620           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16621           0 :   if (!SWIG_IsOK(res1)) {
   16622           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_numlabels_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16623             :   }
   16624           0 :   arg1 = (struct classObj *)(argp1);
   16625           0 :   result = (int) ((arg1)->numlabels);
   16626             :   resultobj = SWIG_From_int((int)(result));
   16627           0 :   return resultobj;
   16628           0 : fail:
   16629             :   return NULL;
   16630             : }
   16631             : 
   16632             : 
   16633           1 : SWIGINTERN PyObject *_wrap_classObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16634             :   PyObject *resultobj = 0;
   16635             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16636           1 :   void *argp1 = 0 ;
   16637             :   int res1 = 0 ;
   16638           1 :   PyObject * obj0 = 0 ;
   16639             :   int result;
   16640             :   
   16641           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_refcount_get",&obj0)) SWIG_fail;
   16642           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16643           1 :   if (!SWIG_IsOK(res1)) {
   16644           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_refcount_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16645             :   }
   16646           1 :   arg1 = (struct classObj *)(argp1);
   16647           1 :   result = (int) ((arg1)->refcount);
   16648             :   resultobj = SWIG_From_int((int)(result));
   16649           1 :   return resultobj;
   16650           0 : fail:
   16651             :   return NULL;
   16652             : }
   16653             : 
   16654             : 
   16655           1 : SWIGINTERN PyObject *_wrap_classObj_layer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16656             :   PyObject *resultobj = 0;
   16657             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16658           1 :   void *argp1 = 0 ;
   16659             :   int res1 = 0 ;
   16660           1 :   PyObject * obj0 = 0 ;
   16661             :   struct layerObj *result = 0 ;
   16662             :   
   16663           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_layer_get",&obj0)) SWIG_fail;
   16664           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16665           1 :   if (!SWIG_IsOK(res1)) {
   16666           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_layer_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16667             :   }
   16668           1 :   arg1 = (struct classObj *)(argp1);
   16669           1 :   result = (struct layerObj *) ((arg1)->layer);
   16670           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, 0 |  0 );
   16671           1 :   return resultobj;
   16672           0 : fail:
   16673             :   return NULL;
   16674             : }
   16675             : 
   16676             : 
   16677           0 : SWIGINTERN PyObject *_wrap_classObj_leader_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16678             :   PyObject *resultobj = 0;
   16679             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16680           0 :   void *argp1 = 0 ;
   16681             :   int res1 = 0 ;
   16682           0 :   PyObject * obj0 = 0 ;
   16683             :   labelLeaderObj *result = 0 ;
   16684             :   
   16685           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_leader_get",&obj0)) SWIG_fail;
   16686           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16687           0 :   if (!SWIG_IsOK(res1)) {
   16688           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_leader_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16689             :   }
   16690           0 :   arg1 = (struct classObj *)(argp1);
   16691           0 :   result = (labelLeaderObj *) ((arg1)->leader);
   16692           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelLeaderObj, 0 |  0 );
   16693           0 :   return resultobj;
   16694           0 : fail:
   16695             :   return NULL;
   16696             : }
   16697             : 
   16698             : 
   16699           1 : SWIGINTERN PyObject *_wrap_classObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16700             :   PyObject *resultobj = 0;
   16701             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16702             :   int arg2 ;
   16703           1 :   void *argp1 = 0 ;
   16704             :   int res1 = 0 ;
   16705             :   int val2 ;
   16706             :   int ecode2 = 0 ;
   16707           1 :   PyObject * obj0 = 0 ;
   16708           1 :   PyObject * obj1 = 0 ;
   16709             :   
   16710           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_status_set",&obj0,&obj1)) SWIG_fail;
   16711           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16712           1 :   if (!SWIG_IsOK(res1)) {
   16713           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_status_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   16714             :   }
   16715           1 :   arg1 = (struct classObj *)(argp1);
   16716           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   16717           1 :   if (!SWIG_IsOK(ecode2)) {
   16718           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_status_set" "', argument " "2"" of type '" "int""'");
   16719             :   } 
   16720             :   arg2 = (int)(val2);
   16721           1 :   if (arg1) (arg1)->status = arg2;
   16722             :   resultobj = SWIG_Py_Void();
   16723           1 :   return resultobj;
   16724           0 : fail:
   16725             :   return NULL;
   16726             : }
   16727             : 
   16728             : 
   16729           1 : SWIGINTERN PyObject *_wrap_classObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16730             :   PyObject *resultobj = 0;
   16731             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16732           1 :   void *argp1 = 0 ;
   16733             :   int res1 = 0 ;
   16734           1 :   PyObject * obj0 = 0 ;
   16735             :   int result;
   16736             :   
   16737           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_status_get",&obj0)) SWIG_fail;
   16738           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16739           1 :   if (!SWIG_IsOK(res1)) {
   16740           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_status_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16741             :   }
   16742           1 :   arg1 = (struct classObj *)(argp1);
   16743           1 :   result = (int) ((arg1)->status);
   16744             :   resultobj = SWIG_From_int((int)(result));
   16745           1 :   return resultobj;
   16746           0 : fail:
   16747             :   return NULL;
   16748             : }
   16749             : 
   16750             : 
   16751           0 : SWIGINTERN PyObject *_wrap_classObj_isfallback_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16752             :   PyObject *resultobj = 0;
   16753             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16754             :   int arg2 ;
   16755           0 :   void *argp1 = 0 ;
   16756             :   int res1 = 0 ;
   16757             :   int val2 ;
   16758             :   int ecode2 = 0 ;
   16759           0 :   PyObject * obj0 = 0 ;
   16760           0 :   PyObject * obj1 = 0 ;
   16761             :   
   16762           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_isfallback_set",&obj0,&obj1)) SWIG_fail;
   16763           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16764           0 :   if (!SWIG_IsOK(res1)) {
   16765           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_isfallback_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   16766             :   }
   16767           0 :   arg1 = (struct classObj *)(argp1);
   16768           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   16769           0 :   if (!SWIG_IsOK(ecode2)) {
   16770           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_isfallback_set" "', argument " "2"" of type '" "int""'");
   16771             :   } 
   16772             :   arg2 = (int)(val2);
   16773           0 :   if (arg1) (arg1)->isfallback = arg2;
   16774             :   resultobj = SWIG_Py_Void();
   16775           0 :   return resultobj;
   16776           0 : fail:
   16777             :   return NULL;
   16778             : }
   16779             : 
   16780             : 
   16781           0 : SWIGINTERN PyObject *_wrap_classObj_isfallback_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16782             :   PyObject *resultobj = 0;
   16783             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16784           0 :   void *argp1 = 0 ;
   16785             :   int res1 = 0 ;
   16786           0 :   PyObject * obj0 = 0 ;
   16787             :   int result;
   16788             :   
   16789           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_isfallback_get",&obj0)) SWIG_fail;
   16790           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16791           0 :   if (!SWIG_IsOK(res1)) {
   16792           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_isfallback_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16793             :   }
   16794           0 :   arg1 = (struct classObj *)(argp1);
   16795           0 :   result = (int) ((arg1)->isfallback);
   16796             :   resultobj = SWIG_From_int((int)(result));
   16797           0 :   return resultobj;
   16798           0 : fail:
   16799             :   return NULL;
   16800             : }
   16801             : 
   16802             : 
   16803           1 : SWIGINTERN PyObject *_wrap_classObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16804             :   PyObject *resultobj = 0;
   16805             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16806             :   char *arg2 = (char *) 0 ;
   16807           1 :   void *argp1 = 0 ;
   16808             :   int res1 = 0 ;
   16809             :   int res2 ;
   16810           1 :   char *buf2 = 0 ;
   16811           1 :   int alloc2 = 0 ;
   16812           1 :   PyObject * obj0 = 0 ;
   16813           1 :   PyObject * obj1 = 0 ;
   16814             :   
   16815           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_name_set",&obj0,&obj1)) SWIG_fail;
   16816           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16817           1 :   if (!SWIG_IsOK(res1)) {
   16818           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_name_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   16819             :   }
   16820           1 :   arg1 = (struct classObj *)(argp1);
   16821           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   16822           1 :   if (!SWIG_IsOK(res2)) {
   16823           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_name_set" "', argument " "2"" of type '" "char *""'");
   16824             :   }
   16825           1 :   arg2 = (char *)(buf2);
   16826             :   {
   16827           1 :     if (arg1->name) free((char*)arg1->name);
   16828           1 :     if (arg2) {
   16829           1 :       arg1->name = (char *) malloc(strlen(arg2)+1);
   16830             :       strcpy((char*)arg1->name,arg2);
   16831             :     } else {
   16832           0 :       arg1->name = 0;
   16833             :     }
   16834             :   }
   16835             :   resultobj = SWIG_Py_Void();
   16836           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16837             :   return resultobj;
   16838           0 : fail:
   16839           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16840             :   return NULL;
   16841             : }
   16842             : 
   16843             : 
   16844           1 : SWIGINTERN PyObject *_wrap_classObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16845             :   PyObject *resultobj = 0;
   16846             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16847           1 :   void *argp1 = 0 ;
   16848             :   int res1 = 0 ;
   16849           1 :   PyObject * obj0 = 0 ;
   16850             :   char *result = 0 ;
   16851             :   
   16852           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_name_get",&obj0)) SWIG_fail;
   16853           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16854           1 :   if (!SWIG_IsOK(res1)) {
   16855           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_name_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16856             :   }
   16857           1 :   arg1 = (struct classObj *)(argp1);
   16858           1 :   result = (char *) ((arg1)->name);
   16859           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   16860           1 :   return resultobj;
   16861           0 : fail:
   16862             :   return NULL;
   16863             : }
   16864             : 
   16865             : 
   16866           1 : SWIGINTERN PyObject *_wrap_classObj_title_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16867             :   PyObject *resultobj = 0;
   16868             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16869             :   char *arg2 = (char *) 0 ;
   16870           1 :   void *argp1 = 0 ;
   16871             :   int res1 = 0 ;
   16872             :   int res2 ;
   16873           1 :   char *buf2 = 0 ;
   16874           1 :   int alloc2 = 0 ;
   16875           1 :   PyObject * obj0 = 0 ;
   16876           1 :   PyObject * obj1 = 0 ;
   16877             :   
   16878           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_title_set",&obj0,&obj1)) SWIG_fail;
   16879           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16880           1 :   if (!SWIG_IsOK(res1)) {
   16881           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_title_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   16882             :   }
   16883           1 :   arg1 = (struct classObj *)(argp1);
   16884           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   16885           1 :   if (!SWIG_IsOK(res2)) {
   16886           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_title_set" "', argument " "2"" of type '" "char *""'");
   16887             :   }
   16888           1 :   arg2 = (char *)(buf2);
   16889             :   {
   16890           1 :     if (arg1->title) free((char*)arg1->title);
   16891           1 :     if (arg2) {
   16892           1 :       arg1->title = (char *) malloc(strlen(arg2)+1);
   16893             :       strcpy((char*)arg1->title,arg2);
   16894             :     } else {
   16895           0 :       arg1->title = 0;
   16896             :     }
   16897             :   }
   16898             :   resultobj = SWIG_Py_Void();
   16899           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16900             :   return resultobj;
   16901           0 : fail:
   16902           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   16903             :   return NULL;
   16904             : }
   16905             : 
   16906             : 
   16907           1 : SWIGINTERN PyObject *_wrap_classObj_title_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16908             :   PyObject *resultobj = 0;
   16909             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16910           1 :   void *argp1 = 0 ;
   16911             :   int res1 = 0 ;
   16912           1 :   PyObject * obj0 = 0 ;
   16913             :   char *result = 0 ;
   16914             :   
   16915           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_title_get",&obj0)) SWIG_fail;
   16916           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16917           1 :   if (!SWIG_IsOK(res1)) {
   16918           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_title_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16919             :   }
   16920           1 :   arg1 = (struct classObj *)(argp1);
   16921           1 :   result = (char *) ((arg1)->title);
   16922           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   16923           1 :   return resultobj;
   16924           0 : fail:
   16925             :   return NULL;
   16926             : }
   16927             : 
   16928             : 
   16929           1 : SWIGINTERN PyObject *_wrap_classObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16930             :   PyObject *resultobj = 0;
   16931             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16932             :   double arg2 ;
   16933           1 :   void *argp1 = 0 ;
   16934             :   int res1 = 0 ;
   16935             :   double val2 ;
   16936             :   int ecode2 = 0 ;
   16937           1 :   PyObject * obj0 = 0 ;
   16938           1 :   PyObject * obj1 = 0 ;
   16939             :   
   16940           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
   16941           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16942           1 :   if (!SWIG_IsOK(res1)) {
   16943           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minscaledenom_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   16944             :   }
   16945           1 :   arg1 = (struct classObj *)(argp1);
   16946           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   16947           1 :   if (!SWIG_IsOK(ecode2)) {
   16948           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
   16949             :   } 
   16950           1 :   arg2 = (double)(val2);
   16951           1 :   if (arg1) (arg1)->minscaledenom = arg2;
   16952             :   resultobj = SWIG_Py_Void();
   16953           1 :   return resultobj;
   16954           0 : fail:
   16955             :   return NULL;
   16956             : }
   16957             : 
   16958             : 
   16959           1 : SWIGINTERN PyObject *_wrap_classObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16960             :   PyObject *resultobj = 0;
   16961             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16962           1 :   void *argp1 = 0 ;
   16963             :   int res1 = 0 ;
   16964           1 :   PyObject * obj0 = 0 ;
   16965             :   double result;
   16966             :   
   16967           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_minscaledenom_get",&obj0)) SWIG_fail;
   16968           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16969           1 :   if (!SWIG_IsOK(res1)) {
   16970           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minscaledenom_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   16971             :   }
   16972           1 :   arg1 = (struct classObj *)(argp1);
   16973           1 :   result = (double) ((arg1)->minscaledenom);
   16974           1 :   resultobj = SWIG_From_double((double)(result));
   16975           1 :   return resultobj;
   16976           0 : fail:
   16977             :   return NULL;
   16978             : }
   16979             : 
   16980             : 
   16981           1 : SWIGINTERN PyObject *_wrap_classObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   16982             :   PyObject *resultobj = 0;
   16983             :   struct classObj *arg1 = (struct classObj *) 0 ;
   16984             :   double arg2 ;
   16985           1 :   void *argp1 = 0 ;
   16986             :   int res1 = 0 ;
   16987             :   double val2 ;
   16988             :   int ecode2 = 0 ;
   16989           1 :   PyObject * obj0 = 0 ;
   16990           1 :   PyObject * obj1 = 0 ;
   16991             :   
   16992           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
   16993           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   16994           1 :   if (!SWIG_IsOK(res1)) {
   16995           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_maxscaledenom_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   16996             :   }
   16997           1 :   arg1 = (struct classObj *)(argp1);
   16998           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   16999           1 :   if (!SWIG_IsOK(ecode2)) {
   17000           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
   17001             :   } 
   17002           1 :   arg2 = (double)(val2);
   17003           1 :   if (arg1) (arg1)->maxscaledenom = arg2;
   17004             :   resultobj = SWIG_Py_Void();
   17005           1 :   return resultobj;
   17006           0 : fail:
   17007             :   return NULL;
   17008             : }
   17009             : 
   17010             : 
   17011           1 : SWIGINTERN PyObject *_wrap_classObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17012             :   PyObject *resultobj = 0;
   17013             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17014           1 :   void *argp1 = 0 ;
   17015             :   int res1 = 0 ;
   17016           1 :   PyObject * obj0 = 0 ;
   17017             :   double result;
   17018             :   
   17019           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_maxscaledenom_get",&obj0)) SWIG_fail;
   17020           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17021           1 :   if (!SWIG_IsOK(res1)) {
   17022           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_maxscaledenom_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17023             :   }
   17024           1 :   arg1 = (struct classObj *)(argp1);
   17025           1 :   result = (double) ((arg1)->maxscaledenom);
   17026           1 :   resultobj = SWIG_From_double((double)(result));
   17027           1 :   return resultobj;
   17028           0 : fail:
   17029             :   return NULL;
   17030             : }
   17031             : 
   17032             : 
   17033           1 : SWIGINTERN PyObject *_wrap_classObj_minfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17034             :   PyObject *resultobj = 0;
   17035             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17036             :   int arg2 ;
   17037           1 :   void *argp1 = 0 ;
   17038             :   int res1 = 0 ;
   17039             :   int val2 ;
   17040             :   int ecode2 = 0 ;
   17041           1 :   PyObject * obj0 = 0 ;
   17042           1 :   PyObject * obj1 = 0 ;
   17043             :   
   17044           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_minfeaturesize_set",&obj0,&obj1)) SWIG_fail;
   17045           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17046           1 :   if (!SWIG_IsOK(res1)) {
   17047           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minfeaturesize_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   17048             :   }
   17049           1 :   arg1 = (struct classObj *)(argp1);
   17050           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   17051           1 :   if (!SWIG_IsOK(ecode2)) {
   17052           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_minfeaturesize_set" "', argument " "2"" of type '" "int""'");
   17053             :   } 
   17054             :   arg2 = (int)(val2);
   17055           1 :   if (arg1) (arg1)->minfeaturesize = arg2;
   17056             :   resultobj = SWIG_Py_Void();
   17057           1 :   return resultobj;
   17058           0 : fail:
   17059             :   return NULL;
   17060             : }
   17061             : 
   17062             : 
   17063           1 : SWIGINTERN PyObject *_wrap_classObj_minfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17064             :   PyObject *resultobj = 0;
   17065             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17066           1 :   void *argp1 = 0 ;
   17067             :   int res1 = 0 ;
   17068           1 :   PyObject * obj0 = 0 ;
   17069             :   int result;
   17070             :   
   17071           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_minfeaturesize_get",&obj0)) SWIG_fail;
   17072           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17073           1 :   if (!SWIG_IsOK(res1)) {
   17074           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minfeaturesize_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17075             :   }
   17076           1 :   arg1 = (struct classObj *)(argp1);
   17077           1 :   result = (int) ((arg1)->minfeaturesize);
   17078             :   resultobj = SWIG_From_int((int)(result));
   17079           1 :   return resultobj;
   17080           0 : fail:
   17081             :   return NULL;
   17082             : }
   17083             : 
   17084             : 
   17085           1 : SWIGINTERN PyObject *_wrap_classObj_debug_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17086             :   PyObject *resultobj = 0;
   17087             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17088             :   int arg2 ;
   17089           1 :   void *argp1 = 0 ;
   17090             :   int res1 = 0 ;
   17091             :   int val2 ;
   17092             :   int ecode2 = 0 ;
   17093           1 :   PyObject * obj0 = 0 ;
   17094           1 :   PyObject * obj1 = 0 ;
   17095             :   
   17096           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_debug_set",&obj0,&obj1)) SWIG_fail;
   17097           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17098           1 :   if (!SWIG_IsOK(res1)) {
   17099           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_debug_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   17100             :   }
   17101           1 :   arg1 = (struct classObj *)(argp1);
   17102           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   17103           1 :   if (!SWIG_IsOK(ecode2)) {
   17104           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_debug_set" "', argument " "2"" of type '" "int""'");
   17105             :   } 
   17106             :   arg2 = (int)(val2);
   17107           1 :   if (arg1) (arg1)->debug = arg2;
   17108             :   resultobj = SWIG_Py_Void();
   17109           1 :   return resultobj;
   17110           0 : fail:
   17111             :   return NULL;
   17112             : }
   17113             : 
   17114             : 
   17115           1 : SWIGINTERN PyObject *_wrap_classObj_debug_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17116             :   PyObject *resultobj = 0;
   17117             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17118           1 :   void *argp1 = 0 ;
   17119             :   int res1 = 0 ;
   17120           1 :   PyObject * obj0 = 0 ;
   17121             :   int result;
   17122             :   
   17123           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_debug_get",&obj0)) SWIG_fail;
   17124           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17125           1 :   if (!SWIG_IsOK(res1)) {
   17126           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_debug_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17127             :   }
   17128           1 :   arg1 = (struct classObj *)(argp1);
   17129           1 :   result = (int) ((arg1)->debug);
   17130             :   resultobj = SWIG_From_int((int)(result));
   17131           1 :   return resultobj;
   17132           0 : fail:
   17133             :   return NULL;
   17134             : }
   17135             : 
   17136             : 
   17137           1 : SWIGINTERN PyObject *_wrap_classObj_keyimage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17138             :   PyObject *resultobj = 0;
   17139             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17140             :   char *arg2 = (char *) 0 ;
   17141           1 :   void *argp1 = 0 ;
   17142             :   int res1 = 0 ;
   17143             :   int res2 ;
   17144           1 :   char *buf2 = 0 ;
   17145           1 :   int alloc2 = 0 ;
   17146           1 :   PyObject * obj0 = 0 ;
   17147           1 :   PyObject * obj1 = 0 ;
   17148             :   
   17149           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_keyimage_set",&obj0,&obj1)) SWIG_fail;
   17150           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17151           1 :   if (!SWIG_IsOK(res1)) {
   17152           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_keyimage_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   17153             :   }
   17154           1 :   arg1 = (struct classObj *)(argp1);
   17155           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17156           1 :   if (!SWIG_IsOK(res2)) {
   17157           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_keyimage_set" "', argument " "2"" of type '" "char *""'");
   17158             :   }
   17159           1 :   arg2 = (char *)(buf2);
   17160             :   {
   17161           1 :     if (arg1->keyimage) free((char*)arg1->keyimage);
   17162           1 :     if (arg2) {
   17163           1 :       arg1->keyimage = (char *) malloc(strlen(arg2)+1);
   17164             :       strcpy((char*)arg1->keyimage,arg2);
   17165             :     } else {
   17166           0 :       arg1->keyimage = 0;
   17167             :     }
   17168             :   }
   17169             :   resultobj = SWIG_Py_Void();
   17170           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17171             :   return resultobj;
   17172           0 : fail:
   17173           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17174             :   return NULL;
   17175             : }
   17176             : 
   17177             : 
   17178           1 : SWIGINTERN PyObject *_wrap_classObj_keyimage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17179             :   PyObject *resultobj = 0;
   17180             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17181           1 :   void *argp1 = 0 ;
   17182             :   int res1 = 0 ;
   17183           1 :   PyObject * obj0 = 0 ;
   17184             :   char *result = 0 ;
   17185             :   
   17186           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_keyimage_get",&obj0)) SWIG_fail;
   17187           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17188           1 :   if (!SWIG_IsOK(res1)) {
   17189           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_keyimage_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17190             :   }
   17191           1 :   arg1 = (struct classObj *)(argp1);
   17192           1 :   result = (char *) ((arg1)->keyimage);
   17193           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17194           1 :   return resultobj;
   17195           0 : fail:
   17196             :   return NULL;
   17197             : }
   17198             : 
   17199             : 
   17200           1 : SWIGINTERN PyObject *_wrap_classObj_group_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17201             :   PyObject *resultobj = 0;
   17202             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17203             :   char *arg2 = (char *) 0 ;
   17204           1 :   void *argp1 = 0 ;
   17205             :   int res1 = 0 ;
   17206             :   int res2 ;
   17207           1 :   char *buf2 = 0 ;
   17208           1 :   int alloc2 = 0 ;
   17209           1 :   PyObject * obj0 = 0 ;
   17210           1 :   PyObject * obj1 = 0 ;
   17211             :   
   17212           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_group_set",&obj0,&obj1)) SWIG_fail;
   17213           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17214           1 :   if (!SWIG_IsOK(res1)) {
   17215           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_group_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   17216             :   }
   17217           1 :   arg1 = (struct classObj *)(argp1);
   17218           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17219           1 :   if (!SWIG_IsOK(res2)) {
   17220           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_group_set" "', argument " "2"" of type '" "char *""'");
   17221             :   }
   17222           1 :   arg2 = (char *)(buf2);
   17223             :   {
   17224           1 :     if (arg1->group) free((char*)arg1->group);
   17225           1 :     if (arg2) {
   17226           1 :       arg1->group = (char *) malloc(strlen(arg2)+1);
   17227             :       strcpy((char*)arg1->group,arg2);
   17228             :     } else {
   17229           0 :       arg1->group = 0;
   17230             :     }
   17231             :   }
   17232             :   resultobj = SWIG_Py_Void();
   17233           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17234             :   return resultobj;
   17235           0 : fail:
   17236           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17237             :   return NULL;
   17238             : }
   17239             : 
   17240             : 
   17241           1 : SWIGINTERN PyObject *_wrap_classObj_group_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17242             :   PyObject *resultobj = 0;
   17243             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17244           1 :   void *argp1 = 0 ;
   17245             :   int res1 = 0 ;
   17246           1 :   PyObject * obj0 = 0 ;
   17247             :   char *result = 0 ;
   17248             :   
   17249           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_group_get",&obj0)) SWIG_fail;
   17250           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17251           1 :   if (!SWIG_IsOK(res1)) {
   17252           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_group_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17253             :   }
   17254           1 :   arg1 = (struct classObj *)(argp1);
   17255           1 :   result = (char *) ((arg1)->group);
   17256           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17257           1 :   return resultobj;
   17258           0 : fail:
   17259             :   return NULL;
   17260             : }
   17261             : 
   17262             : 
   17263           0 : SWIGINTERN PyObject *_wrap_classObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17264             :   PyObject *resultobj = 0;
   17265             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17266             :   int arg2 ;
   17267           0 :   void *argp1 = 0 ;
   17268             :   int res1 = 0 ;
   17269             :   int val2 ;
   17270             :   int ecode2 = 0 ;
   17271           0 :   PyObject * obj0 = 0 ;
   17272           0 :   PyObject * obj1 = 0 ;
   17273             :   
   17274           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
   17275           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17276           0 :   if (!SWIG_IsOK(res1)) {
   17277           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_sizeunits_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   17278             :   }
   17279           0 :   arg1 = (struct classObj *)(argp1);
   17280           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   17281           0 :   if (!SWIG_IsOK(ecode2)) {
   17282           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
   17283             :   } 
   17284             :   arg2 = (int)(val2);
   17285           0 :   if (arg1) (arg1)->sizeunits = arg2;
   17286             :   resultobj = SWIG_Py_Void();
   17287           0 :   return resultobj;
   17288           0 : fail:
   17289             :   return NULL;
   17290             : }
   17291             : 
   17292             : 
   17293           0 : SWIGINTERN PyObject *_wrap_classObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17294             :   PyObject *resultobj = 0;
   17295             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17296           0 :   void *argp1 = 0 ;
   17297             :   int res1 = 0 ;
   17298           0 :   PyObject * obj0 = 0 ;
   17299             :   int result;
   17300             :   
   17301           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_sizeunits_get",&obj0)) SWIG_fail;
   17302           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17303           0 :   if (!SWIG_IsOK(res1)) {
   17304           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_sizeunits_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17305             :   }
   17306           0 :   arg1 = (struct classObj *)(argp1);
   17307           0 :   result = (int) ((arg1)->sizeunits);
   17308             :   resultobj = SWIG_From_int((int)(result));
   17309           0 :   return resultobj;
   17310           0 : fail:
   17311             :   return NULL;
   17312             : }
   17313             : 
   17314             : 
   17315           1 : SWIGINTERN PyObject *_wrap_classObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17316             :   PyObject *resultobj = 0;
   17317             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17318             :   char *arg2 = (char *) 0 ;
   17319           1 :   void *argp1 = 0 ;
   17320             :   int res1 = 0 ;
   17321             :   int res2 ;
   17322           1 :   char *buf2 = 0 ;
   17323           1 :   int alloc2 = 0 ;
   17324           1 :   PyObject * obj0 = 0 ;
   17325           1 :   PyObject * obj1 = 0 ;
   17326             :   
   17327           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_template_set",&obj0,&obj1)) SWIG_fail;
   17328           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17329           1 :   if (!SWIG_IsOK(res1)) {
   17330           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_template_set" "', argument " "1"" of type '" "struct classObj *""'"); 
   17331             :   }
   17332           1 :   arg1 = (struct classObj *)(argp1);
   17333           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17334           1 :   if (!SWIG_IsOK(res2)) {
   17335           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_template_set" "', argument " "2"" of type '" "char *""'");
   17336             :   }
   17337           1 :   arg2 = (char *)(buf2);
   17338             :   {
   17339           1 :     if (arg1->template) free((char*)arg1->template);
   17340           1 :     if (arg2) {
   17341           1 :       arg1->template = (char *) malloc(strlen(arg2)+1);
   17342             :       strcpy((char*)arg1->template,arg2);
   17343             :     } else {
   17344           0 :       arg1->template = 0;
   17345             :     }
   17346             :   }
   17347             :   resultobj = SWIG_Py_Void();
   17348           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17349             :   return resultobj;
   17350           0 : fail:
   17351           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17352             :   return NULL;
   17353             : }
   17354             : 
   17355             : 
   17356           1 : SWIGINTERN PyObject *_wrap_classObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17357             :   PyObject *resultobj = 0;
   17358             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17359           1 :   void *argp1 = 0 ;
   17360             :   int res1 = 0 ;
   17361           1 :   PyObject * obj0 = 0 ;
   17362             :   char *result = 0 ;
   17363             :   
   17364           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_template_get",&obj0)) SWIG_fail;
   17365           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17366           1 :   if (!SWIG_IsOK(res1)) {
   17367           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_template_get" "', argument " "1"" of type '" "struct classObj *""'"); 
   17368             :   }
   17369           1 :   arg1 = (struct classObj *)(argp1);
   17370           1 :   result = (char *) ((arg1)->template);
   17371           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17372           1 :   return resultobj;
   17373           0 : fail:
   17374             :   return NULL;
   17375             : }
   17376             : 
   17377             : 
   17378           1 : SWIGINTERN PyObject *_wrap_new_classObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17379             :   PyObject *resultobj = 0;
   17380             :   layerObj *arg1 = (layerObj *) NULL ;
   17381           1 :   void *argp1 = 0 ;
   17382             :   int res1 = 0 ;
   17383           1 :   PyObject * obj0 = 0 ;
   17384             :   struct classObj *result = 0 ;
   17385             :   
   17386           1 :   if (!PyArg_ParseTuple(args,(char *)"|O:new_classObj",&obj0)) SWIG_fail;
   17387           1 :   if (obj0) {
   17388           1 :     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   17389           1 :     if (!SWIG_IsOK(res1)) {
   17390           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_classObj" "', argument " "1"" of type '" "layerObj *""'"); 
   17391             :     }
   17392           1 :     arg1 = (layerObj *)(argp1);
   17393             :   }
   17394             :   {
   17395           1 :     result = (struct classObj *)new_classObj(arg1); {
   17396           1 :       errorObj *ms_error = msGetErrorObj();
   17397             :       
   17398           1 :       switch(ms_error->code) {
   17399             :       case MS_NOERR:
   17400             :         break;
   17401           0 :       case MS_NOTFOUND:
   17402           0 :         msResetErrorList();
   17403           0 :         break;
   17404             :       case -1:
   17405             :         break;
   17406           0 :       case MS_IOERR:
   17407           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17408           0 :           _raise_ms_exception();
   17409           0 :           msResetErrorList();
   17410           0 :           return NULL;
   17411             :         }
   17412             :       default:
   17413           0 :         _raise_ms_exception();
   17414           0 :         msResetErrorList();
   17415           0 :         return NULL;
   17416             :       }
   17417             :       
   17418             :     }
   17419             :   }
   17420           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_NEW |  0 );
   17421           1 :   return resultobj;
   17422           0 : fail:
   17423             :   return NULL;
   17424             : }
   17425             : 
   17426             : 
   17427           1 : SWIGINTERN PyObject *_wrap_delete_classObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17428             :   PyObject *resultobj = 0;
   17429             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17430           1 :   void *argp1 = 0 ;
   17431             :   int res1 = 0 ;
   17432           1 :   PyObject * obj0 = 0 ;
   17433             :   
   17434           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_classObj",&obj0)) SWIG_fail;
   17435           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, SWIG_POINTER_DISOWN |  0 );
   17436           1 :   if (!SWIG_IsOK(res1)) {
   17437           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_classObj" "', argument " "1"" of type '" "struct classObj *""'"); 
   17438             :   }
   17439           1 :   arg1 = (struct classObj *)(argp1);
   17440             :   {
   17441           1 :     delete_classObj(arg1); {
   17442           1 :       errorObj *ms_error = msGetErrorObj();
   17443             :       
   17444           1 :       switch(ms_error->code) {
   17445             :       case MS_NOERR:
   17446             :         break;
   17447           0 :       case MS_NOTFOUND:
   17448           0 :         msResetErrorList();
   17449           0 :         break;
   17450             :       case -1:
   17451             :         break;
   17452           0 :       case MS_IOERR:
   17453           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17454           0 :           _raise_ms_exception();
   17455           0 :           msResetErrorList();
   17456           0 :           return NULL;
   17457             :         }
   17458             :       default:
   17459           0 :         _raise_ms_exception();
   17460           0 :         msResetErrorList();
   17461           0 :         return NULL;
   17462             :       }
   17463             :       
   17464             :     }
   17465             :   }
   17466             :   resultobj = SWIG_Py_Void();
   17467           1 :   return resultobj;
   17468           0 : fail:
   17469             :   return NULL;
   17470             : }
   17471             : 
   17472             : 
   17473           0 : SWIGINTERN PyObject *_wrap_classObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17474             :   PyObject *resultobj = 0;
   17475             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17476             :   char *arg2 = (char *) 0 ;
   17477           0 :   void *argp1 = 0 ;
   17478             :   int res1 = 0 ;
   17479             :   int res2 ;
   17480           0 :   char *buf2 = 0 ;
   17481           0 :   int alloc2 = 0 ;
   17482           0 :   PyObject * obj0 = 0 ;
   17483           0 :   PyObject * obj1 = 0 ;
   17484             :   int result;
   17485             :   
   17486           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   17487           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17488           0 :   if (!SWIG_IsOK(res1)) {
   17489           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_updateFromString" "', argument " "1"" of type '" "struct classObj *""'"); 
   17490             :   }
   17491           0 :   arg1 = (struct classObj *)(argp1);
   17492           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17493           0 :   if (!SWIG_IsOK(res2)) {
   17494           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   17495             :   }
   17496           0 :   arg2 = (char *)(buf2);
   17497             :   {
   17498             :     result = (int)classObj_updateFromString(arg1,arg2); {
   17499           0 :       errorObj *ms_error = msGetErrorObj();
   17500             :       
   17501           0 :       switch(ms_error->code) {
   17502             :       case MS_NOERR:
   17503             :         break;
   17504           0 :       case MS_NOTFOUND:
   17505           0 :         msResetErrorList();
   17506           0 :         break;
   17507             :       case -1:
   17508             :         break;
   17509           0 :       case MS_IOERR:
   17510           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17511           0 :           _raise_ms_exception();
   17512           0 :           msResetErrorList();
   17513           0 :           return NULL;
   17514             :         }
   17515             :       default:
   17516           0 :         _raise_ms_exception();
   17517           0 :         msResetErrorList();
   17518           0 :         return NULL;
   17519             :       }
   17520             :       
   17521             :     }
   17522             :   }
   17523             :   resultobj = SWIG_From_int((int)(result));
   17524           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17525             :   return resultobj;
   17526           0 : fail:
   17527           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17528             :   return NULL;
   17529             : }
   17530             : 
   17531             : 
   17532           0 : SWIGINTERN PyObject *_wrap_classObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17533             :   PyObject *resultobj = 0;
   17534             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17535           0 :   void *argp1 = 0 ;
   17536             :   int res1 = 0 ;
   17537           0 :   PyObject * obj0 = 0 ;
   17538             :   char *result = 0 ;
   17539             :   
   17540           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_convertToString",&obj0)) SWIG_fail;
   17541           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17542           0 :   if (!SWIG_IsOK(res1)) {
   17543           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_convertToString" "', argument " "1"" of type '" "struct classObj *""'"); 
   17544             :   }
   17545           0 :   arg1 = (struct classObj *)(argp1);
   17546             :   {
   17547             :     result = (char *)classObj_convertToString(arg1); {
   17548           0 :       errorObj *ms_error = msGetErrorObj();
   17549             :       
   17550           0 :       switch(ms_error->code) {
   17551             :       case MS_NOERR:
   17552             :         break;
   17553           0 :       case MS_NOTFOUND:
   17554           0 :         msResetErrorList();
   17555           0 :         break;
   17556             :       case -1:
   17557             :         break;
   17558           0 :       case MS_IOERR:
   17559           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17560           0 :           _raise_ms_exception();
   17561           0 :           msResetErrorList();
   17562           0 :           return NULL;
   17563             :         }
   17564             :       default:
   17565           0 :         _raise_ms_exception();
   17566           0 :         msResetErrorList();
   17567           0 :         return NULL;
   17568             :       }
   17569             :       
   17570             :     }
   17571             :   }
   17572           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17573           0 :   free((char*)result);
   17574           0 :   return resultobj;
   17575           0 : fail:
   17576             :   return NULL;
   17577             : }
   17578             : 
   17579             : 
   17580           1 : SWIGINTERN PyObject *_wrap_classObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17581             :   PyObject *resultobj = 0;
   17582             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17583           1 :   void *argp1 = 0 ;
   17584             :   int res1 = 0 ;
   17585           1 :   PyObject * obj0 = 0 ;
   17586             :   classObj *result = 0 ;
   17587             :   
   17588           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_clone",&obj0)) SWIG_fail;
   17589           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17590           1 :   if (!SWIG_IsOK(res1)) {
   17591           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_clone" "', argument " "1"" of type '" "struct classObj *""'"); 
   17592             :   }
   17593           1 :   arg1 = (struct classObj *)(argp1);
   17594             :   {
   17595           1 :     result = (classObj *)classObj_clone(arg1); {
   17596           1 :       errorObj *ms_error = msGetErrorObj();
   17597             :       
   17598           1 :       switch(ms_error->code) {
   17599             :       case MS_NOERR:
   17600             :         break;
   17601           0 :       case MS_NOTFOUND:
   17602           0 :         msResetErrorList();
   17603           0 :         break;
   17604             :       case -1:
   17605             :         break;
   17606           0 :       case MS_IOERR:
   17607           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17608           0 :           _raise_ms_exception();
   17609           0 :           msResetErrorList();
   17610           0 :           return NULL;
   17611             :         }
   17612             :       default:
   17613           0 :         _raise_ms_exception();
   17614           0 :         msResetErrorList();
   17615           0 :         return NULL;
   17616             :       }
   17617             :       
   17618             :     }
   17619             :   }
   17620           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_OWN |  0 );
   17621           1 :   return resultobj;
   17622           0 : fail:
   17623             :   return NULL;
   17624             : }
   17625             : 
   17626             : 
   17627           0 : SWIGINTERN PyObject *_wrap_classObj_setExpression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17628             :   PyObject *resultobj = 0;
   17629             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17630             :   char *arg2 = (char *) 0 ;
   17631           0 :   void *argp1 = 0 ;
   17632             :   int res1 = 0 ;
   17633             :   int res2 ;
   17634           0 :   char *buf2 = 0 ;
   17635           0 :   int alloc2 = 0 ;
   17636           0 :   PyObject * obj0 = 0 ;
   17637           0 :   PyObject * obj1 = 0 ;
   17638             :   int result;
   17639             :   
   17640           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_setExpression",&obj0,&obj1)) SWIG_fail;
   17641           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17642           0 :   if (!SWIG_IsOK(res1)) {
   17643           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_setExpression" "', argument " "1"" of type '" "struct classObj *""'"); 
   17644             :   }
   17645           0 :   arg1 = (struct classObj *)(argp1);
   17646           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17647           0 :   if (!SWIG_IsOK(res2)) {
   17648           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_setExpression" "', argument " "2"" of type '" "char *""'");
   17649             :   }
   17650           0 :   arg2 = (char *)(buf2);
   17651             :   {
   17652           0 :     result = (int)classObj_setExpression(arg1,arg2); {
   17653           0 :       errorObj *ms_error = msGetErrorObj();
   17654             :       
   17655           0 :       switch(ms_error->code) {
   17656             :       case MS_NOERR:
   17657             :         break;
   17658           0 :       case MS_NOTFOUND:
   17659           0 :         msResetErrorList();
   17660           0 :         break;
   17661             :       case -1:
   17662             :         break;
   17663           0 :       case MS_IOERR:
   17664           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17665           0 :           _raise_ms_exception();
   17666           0 :           msResetErrorList();
   17667           0 :           return NULL;
   17668             :         }
   17669             :       default:
   17670           0 :         _raise_ms_exception();
   17671           0 :         msResetErrorList();
   17672           0 :         return NULL;
   17673             :       }
   17674             :       
   17675             :     }
   17676             :   }
   17677             :   resultobj = SWIG_From_int((int)(result));
   17678           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17679             :   return resultobj;
   17680           0 : fail:
   17681           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17682             :   return NULL;
   17683             : }
   17684             : 
   17685             : 
   17686           0 : SWIGINTERN PyObject *_wrap_classObj_getExpressionString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17687             :   PyObject *resultobj = 0;
   17688             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17689           0 :   void *argp1 = 0 ;
   17690             :   int res1 = 0 ;
   17691           0 :   PyObject * obj0 = 0 ;
   17692             :   char *result = 0 ;
   17693             :   
   17694           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_getExpressionString",&obj0)) SWIG_fail;
   17695           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17696           0 :   if (!SWIG_IsOK(res1)) {
   17697           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getExpressionString" "', argument " "1"" of type '" "struct classObj *""'"); 
   17698             :   }
   17699           0 :   arg1 = (struct classObj *)(argp1);
   17700             :   {
   17701             :     result = (char *)classObj_getExpressionString(arg1); {
   17702           0 :       errorObj *ms_error = msGetErrorObj();
   17703             :       
   17704           0 :       switch(ms_error->code) {
   17705             :       case MS_NOERR:
   17706             :         break;
   17707           0 :       case MS_NOTFOUND:
   17708           0 :         msResetErrorList();
   17709           0 :         break;
   17710             :       case -1:
   17711             :         break;
   17712           0 :       case MS_IOERR:
   17713           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17714           0 :           _raise_ms_exception();
   17715           0 :           msResetErrorList();
   17716           0 :           return NULL;
   17717             :         }
   17718             :       default:
   17719           0 :         _raise_ms_exception();
   17720           0 :         msResetErrorList();
   17721           0 :         return NULL;
   17722             :       }
   17723             :       
   17724             :     }
   17725             :   }
   17726           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17727           0 :   free((char*)result);
   17728           0 :   return resultobj;
   17729           0 : fail:
   17730             :   return NULL;
   17731             : }
   17732             : 
   17733             : 
   17734           0 : SWIGINTERN PyObject *_wrap_classObj_setText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17735             :   PyObject *resultobj = 0;
   17736             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17737             :   char *arg2 = (char *) 0 ;
   17738           0 :   void *argp1 = 0 ;
   17739             :   int res1 = 0 ;
   17740             :   int res2 ;
   17741           0 :   char *buf2 = 0 ;
   17742           0 :   int alloc2 = 0 ;
   17743           0 :   PyObject * obj0 = 0 ;
   17744           0 :   PyObject * obj1 = 0 ;
   17745             :   int result;
   17746             :   
   17747           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_setText",&obj0,&obj1)) SWIG_fail;
   17748           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17749           0 :   if (!SWIG_IsOK(res1)) {
   17750           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_setText" "', argument " "1"" of type '" "struct classObj *""'"); 
   17751             :   }
   17752           0 :   arg1 = (struct classObj *)(argp1);
   17753           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17754           0 :   if (!SWIG_IsOK(res2)) {
   17755           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_setText" "', argument " "2"" of type '" "char *""'");
   17756             :   }
   17757           0 :   arg2 = (char *)(buf2);
   17758             :   {
   17759           0 :     result = (int)classObj_setText(arg1,arg2); {
   17760           0 :       errorObj *ms_error = msGetErrorObj();
   17761             :       
   17762           0 :       switch(ms_error->code) {
   17763             :       case MS_NOERR:
   17764             :         break;
   17765           0 :       case MS_NOTFOUND:
   17766           0 :         msResetErrorList();
   17767           0 :         break;
   17768             :       case -1:
   17769             :         break;
   17770           0 :       case MS_IOERR:
   17771           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17772           0 :           _raise_ms_exception();
   17773           0 :           msResetErrorList();
   17774           0 :           return NULL;
   17775             :         }
   17776             :       default:
   17777           0 :         _raise_ms_exception();
   17778           0 :         msResetErrorList();
   17779           0 :         return NULL;
   17780             :       }
   17781             :       
   17782             :     }
   17783             :   }
   17784             :   resultobj = SWIG_From_int((int)(result));
   17785           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17786             :   return resultobj;
   17787           0 : fail:
   17788           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17789             :   return NULL;
   17790             : }
   17791             : 
   17792             : 
   17793           0 : SWIGINTERN PyObject *_wrap_classObj_getTextString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17794             :   PyObject *resultobj = 0;
   17795             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17796           0 :   void *argp1 = 0 ;
   17797             :   int res1 = 0 ;
   17798           0 :   PyObject * obj0 = 0 ;
   17799             :   char *result = 0 ;
   17800             :   
   17801           0 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_getTextString",&obj0)) SWIG_fail;
   17802           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17803           0 :   if (!SWIG_IsOK(res1)) {
   17804           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getTextString" "', argument " "1"" of type '" "struct classObj *""'"); 
   17805             :   }
   17806           0 :   arg1 = (struct classObj *)(argp1);
   17807             :   {
   17808             :     result = (char *)classObj_getTextString(arg1); {
   17809           0 :       errorObj *ms_error = msGetErrorObj();
   17810             :       
   17811           0 :       switch(ms_error->code) {
   17812             :       case MS_NOERR:
   17813             :         break;
   17814           0 :       case MS_NOTFOUND:
   17815           0 :         msResetErrorList();
   17816           0 :         break;
   17817             :       case -1:
   17818             :         break;
   17819           0 :       case MS_IOERR:
   17820           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17821           0 :           _raise_ms_exception();
   17822           0 :           msResetErrorList();
   17823           0 :           return NULL;
   17824             :         }
   17825             :       default:
   17826           0 :         _raise_ms_exception();
   17827           0 :         msResetErrorList();
   17828           0 :         return NULL;
   17829             :       }
   17830             :       
   17831             :     }
   17832             :   }
   17833           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17834           0 :   free((char*)result);
   17835           0 :   return resultobj;
   17836           0 : fail:
   17837             :   return NULL;
   17838             : }
   17839             : 
   17840             : 
   17841           0 : SWIGINTERN PyObject *_wrap_classObj_getMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17842             :   PyObject *resultobj = 0;
   17843             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17844             :   char *arg2 = (char *) 0 ;
   17845           0 :   void *argp1 = 0 ;
   17846             :   int res1 = 0 ;
   17847             :   int res2 ;
   17848           0 :   char *buf2 = 0 ;
   17849           0 :   int alloc2 = 0 ;
   17850           0 :   PyObject * obj0 = 0 ;
   17851           0 :   PyObject * obj1 = 0 ;
   17852             :   char *result = 0 ;
   17853             :   
   17854           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getMetaData",&obj0,&obj1)) SWIG_fail;
   17855           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17856           0 :   if (!SWIG_IsOK(res1)) {
   17857           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getMetaData" "', argument " "1"" of type '" "struct classObj *""'"); 
   17858             :   }
   17859           0 :   arg1 = (struct classObj *)(argp1);
   17860           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17861           0 :   if (!SWIG_IsOK(res2)) {
   17862           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_getMetaData" "', argument " "2"" of type '" "char *""'");
   17863             :   }
   17864           0 :   arg2 = (char *)(buf2);
   17865             :   {
   17866           0 :     result = (char *)classObj_getMetaData(arg1,arg2); {
   17867           0 :       errorObj *ms_error = msGetErrorObj();
   17868             :       
   17869           0 :       switch(ms_error->code) {
   17870             :       case MS_NOERR:
   17871             :         break;
   17872           0 :       case MS_NOTFOUND:
   17873           0 :         msResetErrorList();
   17874           0 :         break;
   17875             :       case -1:
   17876             :         break;
   17877           0 :       case MS_IOERR:
   17878           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17879           0 :           _raise_ms_exception();
   17880           0 :           msResetErrorList();
   17881           0 :           return NULL;
   17882             :         }
   17883             :       default:
   17884           0 :         _raise_ms_exception();
   17885           0 :         msResetErrorList();
   17886           0 :         return NULL;
   17887             :       }
   17888             :       
   17889             :     }
   17890             :   }
   17891           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   17892           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17893             :   return resultobj;
   17894           0 : fail:
   17895           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17896             :   return NULL;
   17897             : }
   17898             : 
   17899             : 
   17900           0 : SWIGINTERN PyObject *_wrap_classObj_setMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17901             :   PyObject *resultobj = 0;
   17902             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17903             :   char *arg2 = (char *) 0 ;
   17904             :   char *arg3 = (char *) 0 ;
   17905           0 :   void *argp1 = 0 ;
   17906             :   int res1 = 0 ;
   17907             :   int res2 ;
   17908           0 :   char *buf2 = 0 ;
   17909           0 :   int alloc2 = 0 ;
   17910             :   int res3 ;
   17911           0 :   char *buf3 = 0 ;
   17912           0 :   int alloc3 = 0 ;
   17913           0 :   PyObject * obj0 = 0 ;
   17914           0 :   PyObject * obj1 = 0 ;
   17915           0 :   PyObject * obj2 = 0 ;
   17916             :   int result;
   17917             :   
   17918           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:classObj_setMetaData",&obj0,&obj1,&obj2)) SWIG_fail;
   17919           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17920           0 :   if (!SWIG_IsOK(res1)) {
   17921           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_setMetaData" "', argument " "1"" of type '" "struct classObj *""'"); 
   17922             :   }
   17923           0 :   arg1 = (struct classObj *)(argp1);
   17924           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   17925           0 :   if (!SWIG_IsOK(res2)) {
   17926           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_setMetaData" "', argument " "2"" of type '" "char *""'");
   17927             :   }
   17928           0 :   arg2 = (char *)(buf2);
   17929           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   17930           0 :   if (!SWIG_IsOK(res3)) {
   17931           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "classObj_setMetaData" "', argument " "3"" of type '" "char *""'");
   17932             :   }
   17933           0 :   arg3 = (char *)(buf3);
   17934             :   {
   17935             :     result = (int)classObj_setMetaData(arg1,arg2,arg3); {
   17936           0 :       errorObj *ms_error = msGetErrorObj();
   17937             :       
   17938           0 :       switch(ms_error->code) {
   17939             :       case MS_NOERR:
   17940             :         break;
   17941           0 :       case MS_NOTFOUND:
   17942           0 :         msResetErrorList();
   17943           0 :         break;
   17944             :       case -1:
   17945             :         break;
   17946           0 :       case MS_IOERR:
   17947           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17948           0 :           _raise_ms_exception();
   17949           0 :           msResetErrorList();
   17950           0 :           return NULL;
   17951             :         }
   17952             :       default:
   17953           0 :         _raise_ms_exception();
   17954           0 :         msResetErrorList();
   17955           0 :         return NULL;
   17956             :       }
   17957             :       
   17958             :     }
   17959             :   }
   17960             :   resultobj = SWIG_From_int((int)(result));
   17961           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17962           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   17963             :   return resultobj;
   17964           0 : fail:
   17965           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   17966           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   17967             :   return NULL;
   17968             : }
   17969             : 
   17970             : 
   17971           1 : SWIGINTERN PyObject *_wrap_classObj_getFirstMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   17972             :   PyObject *resultobj = 0;
   17973             :   struct classObj *arg1 = (struct classObj *) 0 ;
   17974           1 :   void *argp1 = 0 ;
   17975             :   int res1 = 0 ;
   17976           1 :   PyObject * obj0 = 0 ;
   17977             :   char *result = 0 ;
   17978             :   
   17979           1 :   if (!PyArg_ParseTuple(args,(char *)"O:classObj_getFirstMetaDataKey",&obj0)) SWIG_fail;
   17980           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   17981           1 :   if (!SWIG_IsOK(res1)) {
   17982           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getFirstMetaDataKey" "', argument " "1"" of type '" "struct classObj *""'"); 
   17983             :   }
   17984           1 :   arg1 = (struct classObj *)(argp1);
   17985             :   {
   17986             :     result = (char *)classObj_getFirstMetaDataKey(arg1); {
   17987           1 :       errorObj *ms_error = msGetErrorObj();
   17988             :       
   17989           1 :       switch(ms_error->code) {
   17990             :       case MS_NOERR:
   17991             :         break;
   17992           0 :       case MS_NOTFOUND:
   17993           0 :         msResetErrorList();
   17994           0 :         break;
   17995             :       case -1:
   17996             :         break;
   17997           0 :       case MS_IOERR:
   17998           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   17999           0 :           _raise_ms_exception();
   18000           0 :           msResetErrorList();
   18001           0 :           return NULL;
   18002             :         }
   18003             :       default:
   18004           0 :         _raise_ms_exception();
   18005           0 :         msResetErrorList();
   18006           0 :         return NULL;
   18007             :       }
   18008             :       
   18009             :     }
   18010             :   }
   18011           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   18012           1 :   return resultobj;
   18013           0 : fail:
   18014             :   return NULL;
   18015             : }
   18016             : 
   18017             : 
   18018           1 : SWIGINTERN PyObject *_wrap_classObj_getNextMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18019             :   PyObject *resultobj = 0;
   18020             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18021             :   char *arg2 = (char *) 0 ;
   18022           1 :   void *argp1 = 0 ;
   18023             :   int res1 = 0 ;
   18024             :   int res2 ;
   18025           1 :   char *buf2 = 0 ;
   18026           1 :   int alloc2 = 0 ;
   18027           1 :   PyObject * obj0 = 0 ;
   18028           1 :   PyObject * obj1 = 0 ;
   18029             :   char *result = 0 ;
   18030             :   
   18031           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getNextMetaDataKey",&obj0,&obj1)) SWIG_fail;
   18032           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18033           1 :   if (!SWIG_IsOK(res1)) {
   18034           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getNextMetaDataKey" "', argument " "1"" of type '" "struct classObj *""'"); 
   18035             :   }
   18036           1 :   arg1 = (struct classObj *)(argp1);
   18037           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   18038           1 :   if (!SWIG_IsOK(res2)) {
   18039           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_getNextMetaDataKey" "', argument " "2"" of type '" "char *""'");
   18040             :   }
   18041           1 :   arg2 = (char *)(buf2);
   18042             :   {
   18043             :     result = (char *)classObj_getNextMetaDataKey(arg1,arg2); {
   18044           1 :       errorObj *ms_error = msGetErrorObj();
   18045             :       
   18046           1 :       switch(ms_error->code) {
   18047             :       case MS_NOERR:
   18048             :         break;
   18049           0 :       case MS_NOTFOUND:
   18050           0 :         msResetErrorList();
   18051           0 :         break;
   18052             :       case -1:
   18053             :         break;
   18054           0 :       case MS_IOERR:
   18055           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18056           0 :           _raise_ms_exception();
   18057           0 :           msResetErrorList();
   18058           0 :           return NULL;
   18059             :         }
   18060             :       default:
   18061           0 :         _raise_ms_exception();
   18062           0 :         msResetErrorList();
   18063           0 :         return NULL;
   18064             :       }
   18065             :       
   18066             :     }
   18067             :   }
   18068           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   18069           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   18070             :   return resultobj;
   18071           0 : fail:
   18072           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   18073             :   return NULL;
   18074             : }
   18075             : 
   18076             : 
   18077           0 : SWIGINTERN PyObject *_wrap_classObj_drawLegendIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18078             :   PyObject *resultobj = 0;
   18079             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18080             :   mapObj *arg2 = (mapObj *) 0 ;
   18081             :   layerObj *arg3 = (layerObj *) 0 ;
   18082             :   int arg4 ;
   18083             :   int arg5 ;
   18084             :   imageObj *arg6 = (imageObj *) 0 ;
   18085             :   int arg7 ;
   18086             :   int arg8 ;
   18087           0 :   void *argp1 = 0 ;
   18088             :   int res1 = 0 ;
   18089           0 :   void *argp2 = 0 ;
   18090             :   int res2 = 0 ;
   18091           0 :   void *argp3 = 0 ;
   18092             :   int res3 = 0 ;
   18093             :   int val4 ;
   18094             :   int ecode4 = 0 ;
   18095             :   int val5 ;
   18096             :   int ecode5 = 0 ;
   18097           0 :   void *argp6 = 0 ;
   18098             :   int res6 = 0 ;
   18099             :   int val7 ;
   18100             :   int ecode7 = 0 ;
   18101             :   int val8 ;
   18102             :   int ecode8 = 0 ;
   18103           0 :   PyObject * obj0 = 0 ;
   18104           0 :   PyObject * obj1 = 0 ;
   18105           0 :   PyObject * obj2 = 0 ;
   18106           0 :   PyObject * obj3 = 0 ;
   18107           0 :   PyObject * obj4 = 0 ;
   18108           0 :   PyObject * obj5 = 0 ;
   18109           0 :   PyObject * obj6 = 0 ;
   18110           0 :   PyObject * obj7 = 0 ;
   18111             :   int result;
   18112             :   
   18113           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:classObj_drawLegendIcon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
   18114           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18115           0 :   if (!SWIG_IsOK(res1)) {
   18116           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_drawLegendIcon" "', argument " "1"" of type '" "struct classObj *""'"); 
   18117             :   }
   18118           0 :   arg1 = (struct classObj *)(argp1);
   18119           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   18120           0 :   if (!SWIG_IsOK(res2)) {
   18121           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_drawLegendIcon" "', argument " "2"" of type '" "mapObj *""'"); 
   18122             :   }
   18123           0 :   arg2 = (mapObj *)(argp2);
   18124           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 |  0 );
   18125           0 :   if (!SWIG_IsOK(res3)) {
   18126           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "classObj_drawLegendIcon" "', argument " "3"" of type '" "layerObj *""'"); 
   18127             :   }
   18128           0 :   arg3 = (layerObj *)(argp3);
   18129           0 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   18130           0 :   if (!SWIG_IsOK(ecode4)) {
   18131           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "classObj_drawLegendIcon" "', argument " "4"" of type '" "int""'");
   18132             :   } 
   18133             :   arg4 = (int)(val4);
   18134           0 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   18135           0 :   if (!SWIG_IsOK(ecode5)) {
   18136           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "classObj_drawLegendIcon" "', argument " "5"" of type '" "int""'");
   18137             :   } 
   18138             :   arg5 = (int)(val5);
   18139           0 :   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_imageObj, 0 |  0 );
   18140           0 :   if (!SWIG_IsOK(res6)) {
   18141           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "classObj_drawLegendIcon" "', argument " "6"" of type '" "imageObj *""'"); 
   18142             :   }
   18143           0 :   arg6 = (imageObj *)(argp6);
   18144           0 :   ecode7 = SWIG_AsVal_int(obj6, &val7);
   18145           0 :   if (!SWIG_IsOK(ecode7)) {
   18146           0 :     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "classObj_drawLegendIcon" "', argument " "7"" of type '" "int""'");
   18147             :   } 
   18148             :   arg7 = (int)(val7);
   18149           0 :   ecode8 = SWIG_AsVal_int(obj7, &val8);
   18150           0 :   if (!SWIG_IsOK(ecode8)) {
   18151           0 :     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "classObj_drawLegendIcon" "', argument " "8"" of type '" "int""'");
   18152             :   } 
   18153             :   arg8 = (int)(val8);
   18154             :   {
   18155           0 :     result = (int)classObj_drawLegendIcon(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); {
   18156           0 :       errorObj *ms_error = msGetErrorObj();
   18157             :       
   18158           0 :       switch(ms_error->code) {
   18159             :       case MS_NOERR:
   18160             :         break;
   18161           0 :       case MS_NOTFOUND:
   18162           0 :         msResetErrorList();
   18163           0 :         break;
   18164             :       case -1:
   18165             :         break;
   18166           0 :       case MS_IOERR:
   18167           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18168           0 :           _raise_ms_exception();
   18169           0 :           msResetErrorList();
   18170           0 :           return NULL;
   18171             :         }
   18172             :       default:
   18173           0 :         _raise_ms_exception();
   18174           0 :         msResetErrorList();
   18175           0 :         return NULL;
   18176             :       }
   18177             :       
   18178             :     }
   18179             :   }
   18180             :   resultobj = SWIG_From_int((int)(result));
   18181           0 :   return resultobj;
   18182           0 : fail:
   18183             :   return NULL;
   18184             : }
   18185             : 
   18186             : 
   18187           1 : SWIGINTERN PyObject *_wrap_classObj_createLegendIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18188             :   PyObject *resultobj = 0;
   18189             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18190             :   mapObj *arg2 = (mapObj *) 0 ;
   18191             :   layerObj *arg3 = (layerObj *) 0 ;
   18192             :   int arg4 ;
   18193             :   int arg5 ;
   18194           1 :   void *argp1 = 0 ;
   18195             :   int res1 = 0 ;
   18196           1 :   void *argp2 = 0 ;
   18197             :   int res2 = 0 ;
   18198           1 :   void *argp3 = 0 ;
   18199             :   int res3 = 0 ;
   18200             :   int val4 ;
   18201             :   int ecode4 = 0 ;
   18202             :   int val5 ;
   18203             :   int ecode5 = 0 ;
   18204           1 :   PyObject * obj0 = 0 ;
   18205           1 :   PyObject * obj1 = 0 ;
   18206           1 :   PyObject * obj2 = 0 ;
   18207           1 :   PyObject * obj3 = 0 ;
   18208           1 :   PyObject * obj4 = 0 ;
   18209             :   imageObj *result = 0 ;
   18210             :   
   18211           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:classObj_createLegendIcon",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   18212           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18213           1 :   if (!SWIG_IsOK(res1)) {
   18214           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_createLegendIcon" "', argument " "1"" of type '" "struct classObj *""'"); 
   18215             :   }
   18216           1 :   arg1 = (struct classObj *)(argp1);
   18217           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   18218           1 :   if (!SWIG_IsOK(res2)) {
   18219           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_createLegendIcon" "', argument " "2"" of type '" "mapObj *""'"); 
   18220             :   }
   18221           1 :   arg2 = (mapObj *)(argp2);
   18222           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 |  0 );
   18223           1 :   if (!SWIG_IsOK(res3)) {
   18224           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "classObj_createLegendIcon" "', argument " "3"" of type '" "layerObj *""'"); 
   18225             :   }
   18226           1 :   arg3 = (layerObj *)(argp3);
   18227           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   18228           1 :   if (!SWIG_IsOK(ecode4)) {
   18229           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "classObj_createLegendIcon" "', argument " "4"" of type '" "int""'");
   18230             :   } 
   18231             :   arg4 = (int)(val4);
   18232           1 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   18233           1 :   if (!SWIG_IsOK(ecode5)) {
   18234           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "classObj_createLegendIcon" "', argument " "5"" of type '" "int""'");
   18235             :   } 
   18236             :   arg5 = (int)(val5);
   18237             :   {
   18238             :     result = (imageObj *)classObj_createLegendIcon(arg1,arg2,arg3,arg4,arg5); {
   18239           1 :       errorObj *ms_error = msGetErrorObj();
   18240             :       
   18241           1 :       switch(ms_error->code) {
   18242             :       case MS_NOERR:
   18243             :         break;
   18244           0 :       case MS_NOTFOUND:
   18245           0 :         msResetErrorList();
   18246           0 :         break;
   18247             :       case -1:
   18248             :         break;
   18249           0 :       case MS_IOERR:
   18250           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18251           0 :           _raise_ms_exception();
   18252           0 :           msResetErrorList();
   18253           0 :           return NULL;
   18254             :         }
   18255             :       default:
   18256           0 :         _raise_ms_exception();
   18257           0 :         msResetErrorList();
   18258           0 :         return NULL;
   18259             :       }
   18260             :       
   18261             :     }
   18262             :   }
   18263           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   18264           1 :   return resultobj;
   18265           0 : fail:
   18266             :   return NULL;
   18267             : }
   18268             : 
   18269             : 
   18270           1 : SWIGINTERN PyObject *_wrap_classObj_getLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18271             :   PyObject *resultobj = 0;
   18272             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18273             :   int arg2 ;
   18274           1 :   void *argp1 = 0 ;
   18275             :   int res1 = 0 ;
   18276             :   int val2 ;
   18277             :   int ecode2 = 0 ;
   18278           1 :   PyObject * obj0 = 0 ;
   18279           1 :   PyObject * obj1 = 0 ;
   18280             :   labelObj *result = 0 ;
   18281             :   
   18282           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getLabel",&obj0,&obj1)) SWIG_fail;
   18283           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18284           1 :   if (!SWIG_IsOK(res1)) {
   18285           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getLabel" "', argument " "1"" of type '" "struct classObj *""'"); 
   18286             :   }
   18287           1 :   arg1 = (struct classObj *)(argp1);
   18288           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   18289           1 :   if (!SWIG_IsOK(ecode2)) {
   18290           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_getLabel" "', argument " "2"" of type '" "int""'");
   18291             :   } 
   18292             :   arg2 = (int)(val2);
   18293             :   {
   18294           1 :     result = (labelObj *)classObj_getLabel(arg1,arg2); {
   18295           1 :       errorObj *ms_error = msGetErrorObj();
   18296             :       
   18297           1 :       switch(ms_error->code) {
   18298             :       case MS_NOERR:
   18299             :         break;
   18300           0 :       case MS_NOTFOUND:
   18301           0 :         msResetErrorList();
   18302           0 :         break;
   18303             :       case -1:
   18304             :         break;
   18305           0 :       case MS_IOERR:
   18306           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18307           0 :           _raise_ms_exception();
   18308           0 :           msResetErrorList();
   18309           0 :           return NULL;
   18310             :         }
   18311             :       default:
   18312           0 :         _raise_ms_exception();
   18313           0 :         msResetErrorList();
   18314           0 :         return NULL;
   18315             :       }
   18316             :       
   18317             :     }
   18318             :   }
   18319           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, SWIG_POINTER_OWN |  0 );
   18320           1 :   return resultobj;
   18321           0 : fail:
   18322             :   return NULL;
   18323             : }
   18324             : 
   18325             : 
   18326           1 : SWIGINTERN PyObject *_wrap_classObj_addLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18327             :   PyObject *resultobj = 0;
   18328             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18329             :   labelObj *arg2 = (labelObj *) 0 ;
   18330           1 :   void *argp1 = 0 ;
   18331             :   int res1 = 0 ;
   18332           1 :   void *argp2 = 0 ;
   18333             :   int res2 = 0 ;
   18334           1 :   PyObject * obj0 = 0 ;
   18335           1 :   PyObject * obj1 = 0 ;
   18336             :   int result;
   18337             :   
   18338           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_addLabel",&obj0,&obj1)) SWIG_fail;
   18339           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18340           1 :   if (!SWIG_IsOK(res1)) {
   18341           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_addLabel" "', argument " "1"" of type '" "struct classObj *""'"); 
   18342             :   }
   18343           1 :   arg1 = (struct classObj *)(argp1);
   18344           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_labelObj, 0 |  0 );
   18345           1 :   if (!SWIG_IsOK(res2)) {
   18346           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_addLabel" "', argument " "2"" of type '" "labelObj *""'"); 
   18347             :   }
   18348           1 :   arg2 = (labelObj *)(argp2);
   18349             :   {
   18350             :     result = (int)classObj_addLabel(arg1,arg2); {
   18351           1 :       errorObj *ms_error = msGetErrorObj();
   18352             :       
   18353           1 :       switch(ms_error->code) {
   18354             :       case MS_NOERR:
   18355             :         break;
   18356           0 :       case MS_NOTFOUND:
   18357           0 :         msResetErrorList();
   18358           0 :         break;
   18359             :       case -1:
   18360             :         break;
   18361           0 :       case MS_IOERR:
   18362           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18363           0 :           _raise_ms_exception();
   18364           0 :           msResetErrorList();
   18365           0 :           return NULL;
   18366             :         }
   18367             :       default:
   18368           0 :         _raise_ms_exception();
   18369           0 :         msResetErrorList();
   18370           0 :         return NULL;
   18371             :       }
   18372             :       
   18373             :     }
   18374             :   }
   18375             :   resultobj = SWIG_From_int((int)(result));
   18376           1 :   return resultobj;
   18377           0 : fail:
   18378             :   return NULL;
   18379             : }
   18380             : 
   18381             : 
   18382           0 : SWIGINTERN PyObject *_wrap_classObj_removeLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18383             :   PyObject *resultobj = 0;
   18384             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18385             :   int arg2 ;
   18386           0 :   void *argp1 = 0 ;
   18387             :   int res1 = 0 ;
   18388             :   int val2 ;
   18389             :   int ecode2 = 0 ;
   18390           0 :   PyObject * obj0 = 0 ;
   18391           0 :   PyObject * obj1 = 0 ;
   18392             :   labelObj *result = 0 ;
   18393             :   
   18394           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_removeLabel",&obj0,&obj1)) SWIG_fail;
   18395           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18396           0 :   if (!SWIG_IsOK(res1)) {
   18397           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_removeLabel" "', argument " "1"" of type '" "struct classObj *""'"); 
   18398             :   }
   18399           0 :   arg1 = (struct classObj *)(argp1);
   18400           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   18401           0 :   if (!SWIG_IsOK(ecode2)) {
   18402           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_removeLabel" "', argument " "2"" of type '" "int""'");
   18403             :   } 
   18404             :   arg2 = (int)(val2);
   18405             :   {
   18406           0 :     result = (labelObj *)classObj_removeLabel(arg1,arg2); {
   18407           0 :       errorObj *ms_error = msGetErrorObj();
   18408             :       
   18409           0 :       switch(ms_error->code) {
   18410             :       case MS_NOERR:
   18411             :         break;
   18412           0 :       case MS_NOTFOUND:
   18413           0 :         msResetErrorList();
   18414           0 :         break;
   18415             :       case -1:
   18416             :         break;
   18417           0 :       case MS_IOERR:
   18418           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18419           0 :           _raise_ms_exception();
   18420           0 :           msResetErrorList();
   18421           0 :           return NULL;
   18422             :         }
   18423             :       default:
   18424           0 :         _raise_ms_exception();
   18425           0 :         msResetErrorList();
   18426           0 :         return NULL;
   18427             :       }
   18428             :       
   18429             :     }
   18430             :   }
   18431           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, SWIG_POINTER_OWN |  0 );
   18432           0 :   return resultobj;
   18433           0 : fail:
   18434             :   return NULL;
   18435             : }
   18436             : 
   18437             : 
   18438           1 : SWIGINTERN PyObject *_wrap_classObj_getStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18439             :   PyObject *resultobj = 0;
   18440             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18441             :   int arg2 ;
   18442           1 :   void *argp1 = 0 ;
   18443             :   int res1 = 0 ;
   18444             :   int val2 ;
   18445             :   int ecode2 = 0 ;
   18446           1 :   PyObject * obj0 = 0 ;
   18447           1 :   PyObject * obj1 = 0 ;
   18448             :   styleObj *result = 0 ;
   18449             :   
   18450           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getStyle",&obj0,&obj1)) SWIG_fail;
   18451           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18452           1 :   if (!SWIG_IsOK(res1)) {
   18453           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getStyle" "', argument " "1"" of type '" "struct classObj *""'"); 
   18454             :   }
   18455           1 :   arg1 = (struct classObj *)(argp1);
   18456           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   18457           1 :   if (!SWIG_IsOK(ecode2)) {
   18458           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_getStyle" "', argument " "2"" of type '" "int""'");
   18459             :   } 
   18460             :   arg2 = (int)(val2);
   18461             :   {
   18462           1 :     result = (styleObj *)classObj_getStyle(arg1,arg2); {
   18463           1 :       errorObj *ms_error = msGetErrorObj();
   18464             :       
   18465           1 :       switch(ms_error->code) {
   18466             :       case MS_NOERR:
   18467             :         break;
   18468           0 :       case MS_NOTFOUND:
   18469           0 :         msResetErrorList();
   18470           0 :         break;
   18471             :       case -1:
   18472             :         break;
   18473           0 :       case MS_IOERR:
   18474           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18475           0 :           _raise_ms_exception();
   18476           0 :           msResetErrorList();
   18477           0 :           return NULL;
   18478             :         }
   18479             :       default:
   18480           0 :         _raise_ms_exception();
   18481           0 :         msResetErrorList();
   18482           0 :         return NULL;
   18483             :       }
   18484             :       
   18485             :     }
   18486             :   }
   18487           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN |  0 );
   18488           1 :   return resultobj;
   18489           0 : fail:
   18490             :   return NULL;
   18491             : }
   18492             : 
   18493             : 
   18494           1 : SWIGINTERN PyObject *_wrap_classObj_insertStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18495             :   PyObject *resultobj = 0;
   18496             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18497             :   styleObj *arg2 = (styleObj *) 0 ;
   18498             :   int arg3 = (int) -1 ;
   18499           1 :   void *argp1 = 0 ;
   18500             :   int res1 = 0 ;
   18501           1 :   void *argp2 = 0 ;
   18502             :   int res2 = 0 ;
   18503             :   int val3 ;
   18504             :   int ecode3 = 0 ;
   18505           1 :   PyObject * obj0 = 0 ;
   18506           1 :   PyObject * obj1 = 0 ;
   18507           1 :   PyObject * obj2 = 0 ;
   18508             :   int result;
   18509             :   
   18510           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:classObj_insertStyle",&obj0,&obj1,&obj2)) SWIG_fail;
   18511           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18512           1 :   if (!SWIG_IsOK(res1)) {
   18513           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_insertStyle" "', argument " "1"" of type '" "struct classObj *""'"); 
   18514             :   }
   18515           1 :   arg1 = (struct classObj *)(argp1);
   18516           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_styleObj, 0 |  0 );
   18517           1 :   if (!SWIG_IsOK(res2)) {
   18518           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_insertStyle" "', argument " "2"" of type '" "styleObj *""'"); 
   18519             :   }
   18520           1 :   arg2 = (styleObj *)(argp2);
   18521           1 :   if (obj2) {
   18522             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   18523           1 :     if (!SWIG_IsOK(ecode3)) {
   18524           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "classObj_insertStyle" "', argument " "3"" of type '" "int""'");
   18525             :     } 
   18526             :     arg3 = (int)(val3);
   18527             :   }
   18528             :   {
   18529             :     result = (int)classObj_insertStyle(arg1,arg2,arg3); {
   18530           1 :       errorObj *ms_error = msGetErrorObj();
   18531             :       
   18532           1 :       switch(ms_error->code) {
   18533             :       case MS_NOERR:
   18534             :         break;
   18535           0 :       case MS_NOTFOUND:
   18536           0 :         msResetErrorList();
   18537           0 :         break;
   18538             :       case -1:
   18539             :         break;
   18540           0 :       case MS_IOERR:
   18541           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18542           0 :           _raise_ms_exception();
   18543           0 :           msResetErrorList();
   18544           0 :           return NULL;
   18545             :         }
   18546             :       default:
   18547           1 :         _raise_ms_exception();
   18548           1 :         msResetErrorList();
   18549           1 :         return NULL;
   18550             :       }
   18551             :       
   18552             :     }
   18553             :   }
   18554             :   resultobj = SWIG_From_int((int)(result));
   18555           1 :   return resultobj;
   18556           0 : fail:
   18557             :   return NULL;
   18558             : }
   18559             : 
   18560             : 
   18561           1 : SWIGINTERN PyObject *_wrap_classObj_removeStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18562             :   PyObject *resultobj = 0;
   18563             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18564             :   int arg2 ;
   18565           1 :   void *argp1 = 0 ;
   18566             :   int res1 = 0 ;
   18567             :   int val2 ;
   18568             :   int ecode2 = 0 ;
   18569           1 :   PyObject * obj0 = 0 ;
   18570           1 :   PyObject * obj1 = 0 ;
   18571             :   styleObj *result = 0 ;
   18572             :   
   18573           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_removeStyle",&obj0,&obj1)) SWIG_fail;
   18574           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18575           1 :   if (!SWIG_IsOK(res1)) {
   18576           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_removeStyle" "', argument " "1"" of type '" "struct classObj *""'"); 
   18577             :   }
   18578           1 :   arg1 = (struct classObj *)(argp1);
   18579           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   18580           1 :   if (!SWIG_IsOK(ecode2)) {
   18581           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_removeStyle" "', argument " "2"" of type '" "int""'");
   18582             :   } 
   18583             :   arg2 = (int)(val2);
   18584             :   {
   18585           1 :     result = (styleObj *)classObj_removeStyle(arg1,arg2); {
   18586           1 :       errorObj *ms_error = msGetErrorObj();
   18587             :       
   18588           1 :       switch(ms_error->code) {
   18589             :       case MS_NOERR:
   18590             :         break;
   18591           0 :       case MS_NOTFOUND:
   18592           0 :         msResetErrorList();
   18593           0 :         break;
   18594             :       case -1:
   18595             :         break;
   18596           0 :       case MS_IOERR:
   18597           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18598           0 :           _raise_ms_exception();
   18599           0 :           msResetErrorList();
   18600           0 :           return NULL;
   18601             :         }
   18602             :       default:
   18603           0 :         _raise_ms_exception();
   18604           0 :         msResetErrorList();
   18605           0 :         return NULL;
   18606             :       }
   18607             :       
   18608             :     }
   18609             :   }
   18610           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN |  0 );
   18611           1 :   return resultobj;
   18612           0 : fail:
   18613             :   return NULL;
   18614             : }
   18615             : 
   18616             : 
   18617           0 : SWIGINTERN PyObject *_wrap_classObj_moveStyleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18618             :   PyObject *resultobj = 0;
   18619             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18620             :   int arg2 ;
   18621           0 :   void *argp1 = 0 ;
   18622             :   int res1 = 0 ;
   18623             :   int val2 ;
   18624             :   int ecode2 = 0 ;
   18625           0 :   PyObject * obj0 = 0 ;
   18626           0 :   PyObject * obj1 = 0 ;
   18627             :   int result;
   18628             :   
   18629           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_moveStyleUp",&obj0,&obj1)) SWIG_fail;
   18630           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18631           0 :   if (!SWIG_IsOK(res1)) {
   18632           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_moveStyleUp" "', argument " "1"" of type '" "struct classObj *""'"); 
   18633             :   }
   18634           0 :   arg1 = (struct classObj *)(argp1);
   18635           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   18636           0 :   if (!SWIG_IsOK(ecode2)) {
   18637           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_moveStyleUp" "', argument " "2"" of type '" "int""'");
   18638             :   } 
   18639             :   arg2 = (int)(val2);
   18640             :   {
   18641             :     result = (int)classObj_moveStyleUp(arg1,arg2); {
   18642           0 :       errorObj *ms_error = msGetErrorObj();
   18643             :       
   18644           0 :       switch(ms_error->code) {
   18645             :       case MS_NOERR:
   18646             :         break;
   18647           0 :       case MS_NOTFOUND:
   18648           0 :         msResetErrorList();
   18649           0 :         break;
   18650             :       case -1:
   18651             :         break;
   18652           0 :       case MS_IOERR:
   18653           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18654           0 :           _raise_ms_exception();
   18655           0 :           msResetErrorList();
   18656           0 :           return NULL;
   18657             :         }
   18658             :       default:
   18659           0 :         _raise_ms_exception();
   18660           0 :         msResetErrorList();
   18661           0 :         return NULL;
   18662             :       }
   18663             :       
   18664             :     }
   18665             :   }
   18666             :   resultobj = SWIG_From_int((int)(result));
   18667           0 :   return resultobj;
   18668           0 : fail:
   18669             :   return NULL;
   18670             : }
   18671             : 
   18672             : 
   18673           0 : SWIGINTERN PyObject *_wrap_classObj_moveStyleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18674             :   PyObject *resultobj = 0;
   18675             :   struct classObj *arg1 = (struct classObj *) 0 ;
   18676             :   int arg2 ;
   18677           0 :   void *argp1 = 0 ;
   18678             :   int res1 = 0 ;
   18679             :   int val2 ;
   18680             :   int ecode2 = 0 ;
   18681           0 :   PyObject * obj0 = 0 ;
   18682           0 :   PyObject * obj1 = 0 ;
   18683             :   int result;
   18684             :   
   18685           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:classObj_moveStyleDown",&obj0,&obj1)) SWIG_fail;
   18686           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 |  0 );
   18687           0 :   if (!SWIG_IsOK(res1)) {
   18688           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_moveStyleDown" "', argument " "1"" of type '" "struct classObj *""'"); 
   18689             :   }
   18690           0 :   arg1 = (struct classObj *)(argp1);
   18691           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   18692           0 :   if (!SWIG_IsOK(ecode2)) {
   18693           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_moveStyleDown" "', argument " "2"" of type '" "int""'");
   18694             :   } 
   18695             :   arg2 = (int)(val2);
   18696             :   {
   18697             :     result = (int)classObj_moveStyleDown(arg1,arg2); {
   18698           0 :       errorObj *ms_error = msGetErrorObj();
   18699             :       
   18700           0 :       switch(ms_error->code) {
   18701             :       case MS_NOERR:
   18702             :         break;
   18703           0 :       case MS_NOTFOUND:
   18704           0 :         msResetErrorList();
   18705           0 :         break;
   18706             :       case -1:
   18707             :         break;
   18708           0 :       case MS_IOERR:
   18709           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18710           0 :           _raise_ms_exception();
   18711           0 :           msResetErrorList();
   18712           0 :           return NULL;
   18713             :         }
   18714             :       default:
   18715           0 :         _raise_ms_exception();
   18716           0 :         msResetErrorList();
   18717           0 :         return NULL;
   18718             :       }
   18719             :       
   18720             :     }
   18721             :   }
   18722             :   resultobj = SWIG_From_int((int)(result));
   18723           0 :   return resultobj;
   18724           0 : fail:
   18725             :   return NULL;
   18726             : }
   18727             : 
   18728             : 
   18729           1 : SWIGINTERN PyObject *classObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18730             :   PyObject *obj;
   18731           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   18732           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_classObj, SWIG_NewClientData(obj));
   18733           1 :   return SWIG_Py_Void();
   18734             : }
   18735             : 
   18736           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_textsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18737             :   PyObject *resultobj = 0;
   18738             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18739           0 :   void *argp1 = 0 ;
   18740             :   int res1 = 0 ;
   18741           0 :   PyObject * obj0 = 0 ;
   18742             :   textSymbolObj **result = 0 ;
   18743             :   
   18744           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_textsymbols_get",&obj0)) SWIG_fail;
   18745           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18746           0 :   if (!SWIG_IsOK(res1)) {
   18747           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_textsymbols_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18748             :   }
   18749           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18750           0 :   result = (textSymbolObj **) ((arg1)->textsymbols);
   18751           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_textSymbolObj, 0 |  0 );
   18752           0 :   return resultobj;
   18753           0 : fail:
   18754             :   return NULL;
   18755             : }
   18756             : 
   18757             : 
   18758           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_numtextsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18759             :   PyObject *resultobj = 0;
   18760             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18761           0 :   void *argp1 = 0 ;
   18762             :   int res1 = 0 ;
   18763           0 :   PyObject * obj0 = 0 ;
   18764             :   int result;
   18765             :   
   18766           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_numtextsymbols_get",&obj0)) SWIG_fail;
   18767           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18768           0 :   if (!SWIG_IsOK(res1)) {
   18769           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_numtextsymbols_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18770             :   }
   18771           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18772           0 :   result = (int) ((arg1)->numtextsymbols);
   18773             :   resultobj = SWIG_From_int((int)(result));
   18774           0 :   return resultobj;
   18775           0 : fail:
   18776             :   return NULL;
   18777             : }
   18778             : 
   18779             : 
   18780           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_layerindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18781             :   PyObject *resultobj = 0;
   18782             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18783           0 :   void *argp1 = 0 ;
   18784             :   int res1 = 0 ;
   18785           0 :   PyObject * obj0 = 0 ;
   18786             :   int result;
   18787             :   
   18788           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_layerindex_get",&obj0)) SWIG_fail;
   18789           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18790           0 :   if (!SWIG_IsOK(res1)) {
   18791           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_layerindex_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18792             :   }
   18793           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18794           0 :   result = (int) ((arg1)->layerindex);
   18795             :   resultobj = SWIG_From_int((int)(result));
   18796           0 :   return resultobj;
   18797           0 : fail:
   18798             :   return NULL;
   18799             : }
   18800             : 
   18801             : 
   18802           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_classindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18803             :   PyObject *resultobj = 0;
   18804             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18805           0 :   void *argp1 = 0 ;
   18806             :   int res1 = 0 ;
   18807           0 :   PyObject * obj0 = 0 ;
   18808             :   int result;
   18809             :   
   18810           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_classindex_get",&obj0)) SWIG_fail;
   18811           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18812           0 :   if (!SWIG_IsOK(res1)) {
   18813           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_classindex_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18814             :   }
   18815           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18816           0 :   result = (int) ((arg1)->classindex);
   18817             :   resultobj = SWIG_From_int((int)(result));
   18818           0 :   return resultobj;
   18819           0 : fail:
   18820             :   return NULL;
   18821             : }
   18822             : 
   18823             : 
   18824           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_point_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18825             :   PyObject *resultobj = 0;
   18826             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18827           0 :   void *argp1 = 0 ;
   18828             :   int res1 = 0 ;
   18829           0 :   PyObject * obj0 = 0 ;
   18830             :   pointObj *result = 0 ;
   18831             :   
   18832           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_point_get",&obj0)) SWIG_fail;
   18833           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18834           0 :   if (!SWIG_IsOK(res1)) {
   18835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_point_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18836             :   }
   18837           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18838           0 :   result = (pointObj *)& ((arg1)->point);
   18839           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, 0 |  0 );
   18840           0 :   return resultobj;
   18841           0 : fail:
   18842             :   return NULL;
   18843             : }
   18844             : 
   18845             : 
   18846           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_bbox_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18847             :   PyObject *resultobj = 0;
   18848             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18849           0 :   void *argp1 = 0 ;
   18850             :   int res1 = 0 ;
   18851           0 :   PyObject * obj0 = 0 ;
   18852             :   rectObj *result = 0 ;
   18853             :   
   18854           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_bbox_get",&obj0)) SWIG_fail;
   18855           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18856           0 :   if (!SWIG_IsOK(res1)) {
   18857           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_bbox_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18858             :   }
   18859           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18860           0 :   result = (rectObj *)& ((arg1)->bbox);
   18861           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   18862           0 :   return resultobj;
   18863           0 : fail:
   18864             :   return NULL;
   18865             : }
   18866             : 
   18867             : 
   18868           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18869             :   PyObject *resultobj = 0;
   18870             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18871           0 :   void *argp1 = 0 ;
   18872             :   int res1 = 0 ;
   18873           0 :   PyObject * obj0 = 0 ;
   18874             :   int result;
   18875             :   
   18876           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_status_get",&obj0)) SWIG_fail;
   18877           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18878           0 :   if (!SWIG_IsOK(res1)) {
   18879           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_status_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18880             :   }
   18881           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18882           0 :   result = (int) ((arg1)->status);
   18883             :   resultobj = SWIG_From_int((int)(result));
   18884           0 :   return resultobj;
   18885           0 : fail:
   18886             :   return NULL;
   18887             : }
   18888             : 
   18889             : 
   18890           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_markerid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18891             :   PyObject *resultobj = 0;
   18892             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18893           0 :   void *argp1 = 0 ;
   18894             :   int res1 = 0 ;
   18895           0 :   PyObject * obj0 = 0 ;
   18896             :   int result;
   18897             :   
   18898           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_markerid_get",&obj0)) SWIG_fail;
   18899           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18900           0 :   if (!SWIG_IsOK(res1)) {
   18901           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_markerid_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18902             :   }
   18903           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18904           0 :   result = (int) ((arg1)->markerid);
   18905             :   resultobj = SWIG_From_int((int)(result));
   18906           0 :   return resultobj;
   18907           0 : fail:
   18908             :   return NULL;
   18909             : }
   18910             : 
   18911             : 
   18912           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_leaderline_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18913             :   PyObject *resultobj = 0;
   18914             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18915           0 :   void *argp1 = 0 ;
   18916             :   int res1 = 0 ;
   18917           0 :   PyObject * obj0 = 0 ;
   18918             :   lineObj *result = 0 ;
   18919             :   
   18920           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_leaderline_get",&obj0)) SWIG_fail;
   18921           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18922           0 :   if (!SWIG_IsOK(res1)) {
   18923           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_leaderline_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18924             :   }
   18925           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18926           0 :   result = (lineObj *) ((arg1)->leaderline);
   18927           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, 0 |  0 );
   18928           0 :   return resultobj;
   18929           0 : fail:
   18930             :   return NULL;
   18931             : }
   18932             : 
   18933             : 
   18934           0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_leaderbbox_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18935             :   PyObject *resultobj = 0;
   18936             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18937           0 :   void *argp1 = 0 ;
   18938             :   int res1 = 0 ;
   18939           0 :   PyObject * obj0 = 0 ;
   18940             :   rectObj *result = 0 ;
   18941             :   
   18942           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_leaderbbox_get",&obj0)) SWIG_fail;
   18943           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   18944           0 :   if (!SWIG_IsOK(res1)) {
   18945           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_leaderbbox_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   18946             :   }
   18947           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   18948           0 :   result = (rectObj *) ((arg1)->leaderbbox);
   18949           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   18950           0 :   return resultobj;
   18951           0 : fail:
   18952             :   return NULL;
   18953             : }
   18954             : 
   18955             : 
   18956           0 : SWIGINTERN PyObject *_wrap_new_labelCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18957             :   PyObject *resultobj = 0;
   18958             :   labelCacheMemberObj *result = 0 ;
   18959             :   
   18960           0 :   if (!PyArg_ParseTuple(args,(char *)":new_labelCacheMemberObj")) SWIG_fail;
   18961             :   {
   18962           0 :     result = (labelCacheMemberObj *)calloc(1, sizeof(labelCacheMemberObj)); {
   18963           0 :       errorObj *ms_error = msGetErrorObj();
   18964             :       
   18965           0 :       switch(ms_error->code) {
   18966             :       case MS_NOERR:
   18967             :         break;
   18968           0 :       case MS_NOTFOUND:
   18969           0 :         msResetErrorList();
   18970           0 :         break;
   18971             :       case -1:
   18972             :         break;
   18973           0 :       case MS_IOERR:
   18974           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   18975           0 :           _raise_ms_exception();
   18976           0 :           msResetErrorList();
   18977           0 :           return NULL;
   18978             :         }
   18979             :       default:
   18980           0 :         _raise_ms_exception();
   18981           0 :         msResetErrorList();
   18982           0 :         return NULL;
   18983             :       }
   18984             :       
   18985             :     }
   18986             :   }
   18987           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheMemberObj, SWIG_POINTER_NEW |  0 );
   18988           0 :   return resultobj;
   18989           0 : fail:
   18990             :   return NULL;
   18991             : }
   18992             : 
   18993             : 
   18994           0 : SWIGINTERN PyObject *_wrap_delete_labelCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   18995             :   PyObject *resultobj = 0;
   18996             :   labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
   18997           0 :   void *argp1 = 0 ;
   18998             :   int res1 = 0 ;
   18999           0 :   PyObject * obj0 = 0 ;
   19000             :   
   19001           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_labelCacheMemberObj",&obj0)) SWIG_fail;
   19002           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, SWIG_POINTER_DISOWN |  0 );
   19003           0 :   if (!SWIG_IsOK(res1)) {
   19004           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelCacheMemberObj" "', argument " "1"" of type '" "labelCacheMemberObj *""'"); 
   19005             :   }
   19006           0 :   arg1 = (labelCacheMemberObj *)(argp1);
   19007             :   {
   19008           0 :     free((char *) arg1); {
   19009           0 :       errorObj *ms_error = msGetErrorObj();
   19010             :       
   19011           0 :       switch(ms_error->code) {
   19012             :       case MS_NOERR:
   19013             :         break;
   19014           0 :       case MS_NOTFOUND:
   19015           0 :         msResetErrorList();
   19016           0 :         break;
   19017             :       case -1:
   19018             :         break;
   19019           0 :       case MS_IOERR:
   19020           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19021           0 :           _raise_ms_exception();
   19022           0 :           msResetErrorList();
   19023           0 :           return NULL;
   19024             :         }
   19025             :       default:
   19026           0 :         _raise_ms_exception();
   19027           0 :         msResetErrorList();
   19028           0 :         return NULL;
   19029             :       }
   19030             :       
   19031             :     }
   19032             :   }
   19033             :   resultobj = SWIG_Py_Void();
   19034           0 :   return resultobj;
   19035           0 : fail:
   19036             :   return NULL;
   19037             : }
   19038             : 
   19039             : 
   19040           1 : SWIGINTERN PyObject *labelCacheMemberObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19041             :   PyObject *obj;
   19042           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   19043           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_labelCacheMemberObj, SWIG_NewClientData(obj));
   19044           1 :   return SWIG_Py_Void();
   19045             : }
   19046             : 
   19047           0 : SWIGINTERN PyObject *_wrap_markerCacheMemberObj_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19048             :   PyObject *resultobj = 0;
   19049             :   markerCacheMemberObj *arg1 = (markerCacheMemberObj *) 0 ;
   19050           0 :   void *argp1 = 0 ;
   19051             :   int res1 = 0 ;
   19052           0 :   PyObject * obj0 = 0 ;
   19053             :   int result;
   19054             :   
   19055           0 :   if (!PyArg_ParseTuple(args,(char *)"O:markerCacheMemberObj_id_get",&obj0)) SWIG_fail;
   19056           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_markerCacheMemberObj, 0 |  0 );
   19057           0 :   if (!SWIG_IsOK(res1)) {
   19058           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "markerCacheMemberObj_id_get" "', argument " "1"" of type '" "markerCacheMemberObj *""'"); 
   19059             :   }
   19060           0 :   arg1 = (markerCacheMemberObj *)(argp1);
   19061           0 :   result = (int) ((arg1)->id);
   19062             :   resultobj = SWIG_From_int((int)(result));
   19063           0 :   return resultobj;
   19064           0 : fail:
   19065             :   return NULL;
   19066             : }
   19067             : 
   19068             : 
   19069           0 : SWIGINTERN PyObject *_wrap_markerCacheMemberObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19070             :   PyObject *resultobj = 0;
   19071             :   markerCacheMemberObj *arg1 = (markerCacheMemberObj *) 0 ;
   19072           0 :   void *argp1 = 0 ;
   19073             :   int res1 = 0 ;
   19074           0 :   PyObject * obj0 = 0 ;
   19075             :   rectObj *result = 0 ;
   19076             :   
   19077           0 :   if (!PyArg_ParseTuple(args,(char *)"O:markerCacheMemberObj_bounds_get",&obj0)) SWIG_fail;
   19078           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_markerCacheMemberObj, 0 |  0 );
   19079           0 :   if (!SWIG_IsOK(res1)) {
   19080           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "markerCacheMemberObj_bounds_get" "', argument " "1"" of type '" "markerCacheMemberObj *""'"); 
   19081             :   }
   19082           0 :   arg1 = (markerCacheMemberObj *)(argp1);
   19083           0 :   result = (rectObj *)& ((arg1)->bounds);
   19084           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   19085           0 :   return resultobj;
   19086           0 : fail:
   19087             :   return NULL;
   19088             : }
   19089             : 
   19090             : 
   19091           0 : SWIGINTERN PyObject *_wrap_new_markerCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19092             :   PyObject *resultobj = 0;
   19093             :   markerCacheMemberObj *result = 0 ;
   19094             :   
   19095           0 :   if (!PyArg_ParseTuple(args,(char *)":new_markerCacheMemberObj")) SWIG_fail;
   19096             :   {
   19097           0 :     result = (markerCacheMemberObj *)calloc(1, sizeof(markerCacheMemberObj)); {
   19098           0 :       errorObj *ms_error = msGetErrorObj();
   19099             :       
   19100           0 :       switch(ms_error->code) {
   19101             :       case MS_NOERR:
   19102             :         break;
   19103           0 :       case MS_NOTFOUND:
   19104           0 :         msResetErrorList();
   19105           0 :         break;
   19106             :       case -1:
   19107             :         break;
   19108           0 :       case MS_IOERR:
   19109           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19110           0 :           _raise_ms_exception();
   19111           0 :           msResetErrorList();
   19112           0 :           return NULL;
   19113             :         }
   19114             :       default:
   19115           0 :         _raise_ms_exception();
   19116           0 :         msResetErrorList();
   19117           0 :         return NULL;
   19118             :       }
   19119             :       
   19120             :     }
   19121             :   }
   19122           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_markerCacheMemberObj, SWIG_POINTER_NEW |  0 );
   19123           0 :   return resultobj;
   19124           0 : fail:
   19125             :   return NULL;
   19126             : }
   19127             : 
   19128             : 
   19129           0 : SWIGINTERN PyObject *_wrap_delete_markerCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19130             :   PyObject *resultobj = 0;
   19131             :   markerCacheMemberObj *arg1 = (markerCacheMemberObj *) 0 ;
   19132           0 :   void *argp1 = 0 ;
   19133             :   int res1 = 0 ;
   19134           0 :   PyObject * obj0 = 0 ;
   19135             :   
   19136           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_markerCacheMemberObj",&obj0)) SWIG_fail;
   19137           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_markerCacheMemberObj, SWIG_POINTER_DISOWN |  0 );
   19138           0 :   if (!SWIG_IsOK(res1)) {
   19139           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_markerCacheMemberObj" "', argument " "1"" of type '" "markerCacheMemberObj *""'"); 
   19140             :   }
   19141           0 :   arg1 = (markerCacheMemberObj *)(argp1);
   19142             :   {
   19143           0 :     free((char *) arg1); {
   19144           0 :       errorObj *ms_error = msGetErrorObj();
   19145             :       
   19146           0 :       switch(ms_error->code) {
   19147             :       case MS_NOERR:
   19148             :         break;
   19149           0 :       case MS_NOTFOUND:
   19150           0 :         msResetErrorList();
   19151           0 :         break;
   19152             :       case -1:
   19153             :         break;
   19154           0 :       case MS_IOERR:
   19155           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19156           0 :           _raise_ms_exception();
   19157           0 :           msResetErrorList();
   19158           0 :           return NULL;
   19159             :         }
   19160             :       default:
   19161           0 :         _raise_ms_exception();
   19162           0 :         msResetErrorList();
   19163           0 :         return NULL;
   19164             :       }
   19165             :       
   19166             :     }
   19167             :   }
   19168             :   resultobj = SWIG_Py_Void();
   19169           0 :   return resultobj;
   19170           0 : fail:
   19171             :   return NULL;
   19172             : }
   19173             : 
   19174             : 
   19175           1 : SWIGINTERN PyObject *markerCacheMemberObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19176             :   PyObject *obj;
   19177           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   19178           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_markerCacheMemberObj, SWIG_NewClientData(obj));
   19179           1 :   return SWIG_Py_Void();
   19180             : }
   19181             : 
   19182           0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_labels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19183             :   PyObject *resultobj = 0;
   19184             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19185           0 :   void *argp1 = 0 ;
   19186             :   int res1 = 0 ;
   19187           0 :   PyObject * obj0 = 0 ;
   19188             :   labelCacheMemberObj *result = 0 ;
   19189             :   
   19190           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_labels_get",&obj0)) SWIG_fail;
   19191           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19192           0 :   if (!SWIG_IsOK(res1)) {
   19193           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_labels_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19194             :   }
   19195           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19196           0 :   result = (labelCacheMemberObj *) ((arg1)->labels);
   19197           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheMemberObj, 0 |  0 );
   19198           0 :   return resultobj;
   19199           0 : fail:
   19200             :   return NULL;
   19201             : }
   19202             : 
   19203             : 
   19204           0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_numlabels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19205             :   PyObject *resultobj = 0;
   19206             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19207           0 :   void *argp1 = 0 ;
   19208             :   int res1 = 0 ;
   19209           0 :   PyObject * obj0 = 0 ;
   19210             :   int result;
   19211             :   
   19212           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_numlabels_get",&obj0)) SWIG_fail;
   19213           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19214           0 :   if (!SWIG_IsOK(res1)) {
   19215           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_numlabels_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19216             :   }
   19217           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19218           0 :   result = (int) ((arg1)->numlabels);
   19219             :   resultobj = SWIG_From_int((int)(result));
   19220           0 :   return resultobj;
   19221           0 : fail:
   19222             :   return NULL;
   19223             : }
   19224             : 
   19225             : 
   19226           0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_cachesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19227             :   PyObject *resultobj = 0;
   19228             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19229           0 :   void *argp1 = 0 ;
   19230             :   int res1 = 0 ;
   19231           0 :   PyObject * obj0 = 0 ;
   19232             :   int result;
   19233             :   
   19234           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_cachesize_get",&obj0)) SWIG_fail;
   19235           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19236           0 :   if (!SWIG_IsOK(res1)) {
   19237           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_cachesize_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19238             :   }
   19239           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19240           0 :   result = (int) ((arg1)->cachesize);
   19241             :   resultobj = SWIG_From_int((int)(result));
   19242           0 :   return resultobj;
   19243           0 : fail:
   19244             :   return NULL;
   19245             : }
   19246             : 
   19247             : 
   19248           0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_markers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19249             :   PyObject *resultobj = 0;
   19250             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19251           0 :   void *argp1 = 0 ;
   19252             :   int res1 = 0 ;
   19253           0 :   PyObject * obj0 = 0 ;
   19254             :   markerCacheMemberObj *result = 0 ;
   19255             :   
   19256           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_markers_get",&obj0)) SWIG_fail;
   19257           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19258           0 :   if (!SWIG_IsOK(res1)) {
   19259           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_markers_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19260             :   }
   19261           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19262           0 :   result = (markerCacheMemberObj *) ((arg1)->markers);
   19263           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_markerCacheMemberObj, 0 |  0 );
   19264           0 :   return resultobj;
   19265           0 : fail:
   19266             :   return NULL;
   19267             : }
   19268             : 
   19269             : 
   19270           0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_nummarkers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19271             :   PyObject *resultobj = 0;
   19272             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19273           0 :   void *argp1 = 0 ;
   19274             :   int res1 = 0 ;
   19275           0 :   PyObject * obj0 = 0 ;
   19276             :   int result;
   19277             :   
   19278           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_nummarkers_get",&obj0)) SWIG_fail;
   19279           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19280           0 :   if (!SWIG_IsOK(res1)) {
   19281           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_nummarkers_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19282             :   }
   19283           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19284           0 :   result = (int) ((arg1)->nummarkers);
   19285             :   resultobj = SWIG_From_int((int)(result));
   19286           0 :   return resultobj;
   19287           0 : fail:
   19288             :   return NULL;
   19289             : }
   19290             : 
   19291             : 
   19292           0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_markercachesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19293             :   PyObject *resultobj = 0;
   19294             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19295           0 :   void *argp1 = 0 ;
   19296             :   int res1 = 0 ;
   19297           0 :   PyObject * obj0 = 0 ;
   19298             :   int result;
   19299             :   
   19300           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_markercachesize_get",&obj0)) SWIG_fail;
   19301           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19302           0 :   if (!SWIG_IsOK(res1)) {
   19303           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_markercachesize_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19304             :   }
   19305           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19306           0 :   result = (int) ((arg1)->markercachesize);
   19307             :   resultobj = SWIG_From_int((int)(result));
   19308           0 :   return resultobj;
   19309           0 : fail:
   19310             :   return NULL;
   19311             : }
   19312             : 
   19313             : 
   19314           0 : SWIGINTERN PyObject *_wrap_new_labelCacheSlotObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19315             :   PyObject *resultobj = 0;
   19316             :   labelCacheSlotObj *result = 0 ;
   19317             :   
   19318           0 :   if (!PyArg_ParseTuple(args,(char *)":new_labelCacheSlotObj")) SWIG_fail;
   19319             :   {
   19320           0 :     result = (labelCacheSlotObj *)calloc(1, sizeof(labelCacheSlotObj)); {
   19321           0 :       errorObj *ms_error = msGetErrorObj();
   19322             :       
   19323           0 :       switch(ms_error->code) {
   19324             :       case MS_NOERR:
   19325             :         break;
   19326           0 :       case MS_NOTFOUND:
   19327           0 :         msResetErrorList();
   19328           0 :         break;
   19329             :       case -1:
   19330             :         break;
   19331           0 :       case MS_IOERR:
   19332           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19333           0 :           _raise_ms_exception();
   19334           0 :           msResetErrorList();
   19335           0 :           return NULL;
   19336             :         }
   19337             :       default:
   19338           0 :         _raise_ms_exception();
   19339           0 :         msResetErrorList();
   19340           0 :         return NULL;
   19341             :       }
   19342             :       
   19343             :     }
   19344             :   }
   19345           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheSlotObj, SWIG_POINTER_NEW |  0 );
   19346           0 :   return resultobj;
   19347           0 : fail:
   19348             :   return NULL;
   19349             : }
   19350             : 
   19351             : 
   19352           0 : SWIGINTERN PyObject *_wrap_delete_labelCacheSlotObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19353             :   PyObject *resultobj = 0;
   19354             :   labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
   19355           0 :   void *argp1 = 0 ;
   19356             :   int res1 = 0 ;
   19357           0 :   PyObject * obj0 = 0 ;
   19358             :   
   19359           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_labelCacheSlotObj",&obj0)) SWIG_fail;
   19360           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, SWIG_POINTER_DISOWN |  0 );
   19361           0 :   if (!SWIG_IsOK(res1)) {
   19362           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelCacheSlotObj" "', argument " "1"" of type '" "labelCacheSlotObj *""'"); 
   19363             :   }
   19364           0 :   arg1 = (labelCacheSlotObj *)(argp1);
   19365             :   {
   19366           0 :     free((char *) arg1); {
   19367           0 :       errorObj *ms_error = msGetErrorObj();
   19368             :       
   19369           0 :       switch(ms_error->code) {
   19370             :       case MS_NOERR:
   19371             :         break;
   19372           0 :       case MS_NOTFOUND:
   19373           0 :         msResetErrorList();
   19374           0 :         break;
   19375             :       case -1:
   19376             :         break;
   19377           0 :       case MS_IOERR:
   19378           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19379           0 :           _raise_ms_exception();
   19380           0 :           msResetErrorList();
   19381           0 :           return NULL;
   19382             :         }
   19383             :       default:
   19384           0 :         _raise_ms_exception();
   19385           0 :         msResetErrorList();
   19386           0 :         return NULL;
   19387             :       }
   19388             :       
   19389             :     }
   19390             :   }
   19391             :   resultobj = SWIG_Py_Void();
   19392           0 :   return resultobj;
   19393           0 : fail:
   19394             :   return NULL;
   19395             : }
   19396             : 
   19397             : 
   19398           1 : SWIGINTERN PyObject *labelCacheSlotObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19399             :   PyObject *obj;
   19400           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   19401           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_labelCacheSlotObj, SWIG_NewClientData(obj));
   19402           1 :   return SWIG_Py_Void();
   19403             : }
   19404             : 
   19405           0 : SWIGINTERN PyObject *_wrap_labelCacheObj_slots_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19406             :   PyObject *resultobj = 0;
   19407             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19408           0 :   void *argp1 = 0 ;
   19409             :   int res1 = 0 ;
   19410           0 :   PyObject * obj0 = 0 ;
   19411             :   labelCacheSlotObj *result = 0 ;
   19412             :   
   19413           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_slots_get",&obj0)) SWIG_fail;
   19414           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 |  0 );
   19415           0 :   if (!SWIG_IsOK(res1)) {
   19416           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_slots_get" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19417             :   }
   19418           0 :   arg1 = (labelCacheObj *)(argp1);
   19419           0 :   result = (labelCacheSlotObj *)(labelCacheSlotObj *) ((arg1)->slots);
   19420           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheSlotObj, 0 |  0 );
   19421           0 :   return resultobj;
   19422           0 : fail:
   19423             :   return NULL;
   19424             : }
   19425             : 
   19426             : 
   19427           0 : SWIGINTERN PyObject *_wrap_labelCacheObj_gutter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19428             :   PyObject *resultobj = 0;
   19429             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19430           0 :   void *argp1 = 0 ;
   19431             :   int res1 = 0 ;
   19432           0 :   PyObject * obj0 = 0 ;
   19433             :   int result;
   19434             :   
   19435           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_gutter_get",&obj0)) SWIG_fail;
   19436           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 |  0 );
   19437           0 :   if (!SWIG_IsOK(res1)) {
   19438           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_gutter_get" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19439             :   }
   19440           0 :   arg1 = (labelCacheObj *)(argp1);
   19441           0 :   result = (int) ((arg1)->gutter);
   19442             :   resultobj = SWIG_From_int((int)(result));
   19443           0 :   return resultobj;
   19444           0 : fail:
   19445             :   return NULL;
   19446             : }
   19447             : 
   19448             : 
   19449           0 : SWIGINTERN PyObject *_wrap_labelCacheObj_rendered_text_symbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19450             :   PyObject *resultobj = 0;
   19451             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19452           0 :   void *argp1 = 0 ;
   19453             :   int res1 = 0 ;
   19454           0 :   PyObject * obj0 = 0 ;
   19455             :   labelCacheMemberObj **result = 0 ;
   19456             :   
   19457           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_rendered_text_symbols_get",&obj0)) SWIG_fail;
   19458           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 |  0 );
   19459           0 :   if (!SWIG_IsOK(res1)) {
   19460           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_rendered_text_symbols_get" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19461             :   }
   19462           0 :   arg1 = (labelCacheObj *)(argp1);
   19463           0 :   result = (labelCacheMemberObj **) ((arg1)->rendered_text_symbols);
   19464           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_labelCacheMemberObj, 0 |  0 );
   19465           0 :   return resultobj;
   19466           0 : fail:
   19467             :   return NULL;
   19468             : }
   19469             : 
   19470             : 
   19471           0 : SWIGINTERN PyObject *_wrap_labelCacheObj_num_allocated_rendered_members_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19472             :   PyObject *resultobj = 0;
   19473             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19474           0 :   void *argp1 = 0 ;
   19475             :   int res1 = 0 ;
   19476           0 :   PyObject * obj0 = 0 ;
   19477             :   int result;
   19478             :   
   19479           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_num_allocated_rendered_members_get",&obj0)) SWIG_fail;
   19480           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 |  0 );
   19481           0 :   if (!SWIG_IsOK(res1)) {
   19482           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_num_allocated_rendered_members_get" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19483             :   }
   19484           0 :   arg1 = (labelCacheObj *)(argp1);
   19485           0 :   result = (int) ((arg1)->num_allocated_rendered_members);
   19486             :   resultobj = SWIG_From_int((int)(result));
   19487           0 :   return resultobj;
   19488           0 : fail:
   19489             :   return NULL;
   19490             : }
   19491             : 
   19492             : 
   19493           1 : SWIGINTERN PyObject *_wrap_labelCacheObj_num_rendered_members_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19494             :   PyObject *resultobj = 0;
   19495             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19496           1 :   void *argp1 = 0 ;
   19497             :   int res1 = 0 ;
   19498           1 :   PyObject * obj0 = 0 ;
   19499             :   int result;
   19500             :   
   19501           1 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_num_rendered_members_get",&obj0)) SWIG_fail;
   19502           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 |  0 );
   19503           1 :   if (!SWIG_IsOK(res1)) {
   19504           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_num_rendered_members_get" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19505             :   }
   19506           1 :   arg1 = (labelCacheObj *)(argp1);
   19507           1 :   result = (int) ((arg1)->num_rendered_members);
   19508             :   resultobj = SWIG_From_int((int)(result));
   19509           1 :   return resultobj;
   19510           0 : fail:
   19511             :   return NULL;
   19512             : }
   19513             : 
   19514             : 
   19515           0 : SWIGINTERN PyObject *_wrap_labelCacheObj_freeCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19516             :   PyObject *resultobj = 0;
   19517             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19518           0 :   void *argp1 = 0 ;
   19519             :   int res1 = 0 ;
   19520           0 :   PyObject * obj0 = 0 ;
   19521             :   
   19522           0 :   if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_freeCache",&obj0)) SWIG_fail;
   19523           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 |  0 );
   19524           0 :   if (!SWIG_IsOK(res1)) {
   19525           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_freeCache" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19526             :   }
   19527           0 :   arg1 = (labelCacheObj *)(argp1);
   19528             :   {
   19529             :     labelCacheObj_freeCache(arg1); {
   19530           0 :       errorObj *ms_error = msGetErrorObj();
   19531             :       
   19532           0 :       switch(ms_error->code) {
   19533             :       case MS_NOERR:
   19534             :         break;
   19535           0 :       case MS_NOTFOUND:
   19536           0 :         msResetErrorList();
   19537           0 :         break;
   19538             :       case -1:
   19539             :         break;
   19540           0 :       case MS_IOERR:
   19541           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19542           0 :           _raise_ms_exception();
   19543           0 :           msResetErrorList();
   19544           0 :           return NULL;
   19545             :         }
   19546             :       default:
   19547           0 :         _raise_ms_exception();
   19548           0 :         msResetErrorList();
   19549           0 :         return NULL;
   19550             :       }
   19551             :       
   19552             :     }
   19553             :   }
   19554             :   resultobj = SWIG_Py_Void();
   19555           0 :   return resultobj;
   19556           0 : fail:
   19557             :   return NULL;
   19558             : }
   19559             : 
   19560             : 
   19561           0 : SWIGINTERN PyObject *_wrap_new_labelCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19562             :   PyObject *resultobj = 0;
   19563             :   labelCacheObj *result = 0 ;
   19564             :   
   19565           0 :   if (!PyArg_ParseTuple(args,(char *)":new_labelCacheObj")) SWIG_fail;
   19566             :   {
   19567           0 :     result = (labelCacheObj *)calloc(1, sizeof(labelCacheObj)); {
   19568           0 :       errorObj *ms_error = msGetErrorObj();
   19569             :       
   19570           0 :       switch(ms_error->code) {
   19571             :       case MS_NOERR:
   19572             :         break;
   19573           0 :       case MS_NOTFOUND:
   19574           0 :         msResetErrorList();
   19575           0 :         break;
   19576             :       case -1:
   19577             :         break;
   19578           0 :       case MS_IOERR:
   19579           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19580           0 :           _raise_ms_exception();
   19581           0 :           msResetErrorList();
   19582           0 :           return NULL;
   19583             :         }
   19584             :       default:
   19585           0 :         _raise_ms_exception();
   19586           0 :         msResetErrorList();
   19587           0 :         return NULL;
   19588             :       }
   19589             :       
   19590             :     }
   19591             :   }
   19592           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheObj, SWIG_POINTER_NEW |  0 );
   19593           0 :   return resultobj;
   19594           0 : fail:
   19595             :   return NULL;
   19596             : }
   19597             : 
   19598             : 
   19599           0 : SWIGINTERN PyObject *_wrap_delete_labelCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19600             :   PyObject *resultobj = 0;
   19601             :   labelCacheObj *arg1 = (labelCacheObj *) 0 ;
   19602           0 :   void *argp1 = 0 ;
   19603             :   int res1 = 0 ;
   19604           0 :   PyObject * obj0 = 0 ;
   19605             :   
   19606           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_labelCacheObj",&obj0)) SWIG_fail;
   19607           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, SWIG_POINTER_DISOWN |  0 );
   19608           0 :   if (!SWIG_IsOK(res1)) {
   19609           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelCacheObj" "', argument " "1"" of type '" "labelCacheObj *""'"); 
   19610             :   }
   19611           0 :   arg1 = (labelCacheObj *)(argp1);
   19612             :   {
   19613           0 :     free((char *) arg1); {
   19614           0 :       errorObj *ms_error = msGetErrorObj();
   19615             :       
   19616           0 :       switch(ms_error->code) {
   19617             :       case MS_NOERR:
   19618             :         break;
   19619           0 :       case MS_NOTFOUND:
   19620           0 :         msResetErrorList();
   19621           0 :         break;
   19622             :       case -1:
   19623             :         break;
   19624           0 :       case MS_IOERR:
   19625           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19626           0 :           _raise_ms_exception();
   19627           0 :           msResetErrorList();
   19628           0 :           return NULL;
   19629             :         }
   19630             :       default:
   19631           0 :         _raise_ms_exception();
   19632           0 :         msResetErrorList();
   19633           0 :         return NULL;
   19634             :       }
   19635             :       
   19636             :     }
   19637             :   }
   19638             :   resultobj = SWIG_Py_Void();
   19639           0 :   return resultobj;
   19640           0 : fail:
   19641             :   return NULL;
   19642             : }
   19643             : 
   19644             : 
   19645           1 : SWIGINTERN PyObject *labelCacheObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19646             :   PyObject *obj;
   19647           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   19648           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_labelCacheObj, SWIG_NewClientData(obj));
   19649           1 :   return SWIG_Py_Void();
   19650             : }
   19651             : 
   19652           1 : SWIGINTERN PyObject *_wrap_resultObj_shapeindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19653             :   PyObject *resultobj = 0;
   19654             :   resultObj *arg1 = (resultObj *) 0 ;
   19655           1 :   void *argp1 = 0 ;
   19656             :   int res1 = 0 ;
   19657           1 :   PyObject * obj0 = 0 ;
   19658             :   long result;
   19659             :   
   19660           1 :   if (!PyArg_ParseTuple(args,(char *)"O:resultObj_shapeindex_get",&obj0)) SWIG_fail;
   19661           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 |  0 );
   19662           1 :   if (!SWIG_IsOK(res1)) {
   19663           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_shapeindex_get" "', argument " "1"" of type '" "resultObj *""'"); 
   19664             :   }
   19665           1 :   arg1 = (resultObj *)(argp1);
   19666           1 :   result = (long) ((arg1)->shapeindex);
   19667           1 :   resultobj = SWIG_From_long((long)(result));
   19668           1 :   return resultobj;
   19669           0 : fail:
   19670             :   return NULL;
   19671             : }
   19672             : 
   19673             : 
   19674           0 : SWIGINTERN PyObject *_wrap_resultObj_tileindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19675             :   PyObject *resultobj = 0;
   19676             :   resultObj *arg1 = (resultObj *) 0 ;
   19677           0 :   void *argp1 = 0 ;
   19678             :   int res1 = 0 ;
   19679           0 :   PyObject * obj0 = 0 ;
   19680             :   int result;
   19681             :   
   19682           0 :   if (!PyArg_ParseTuple(args,(char *)"O:resultObj_tileindex_get",&obj0)) SWIG_fail;
   19683           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 |  0 );
   19684           0 :   if (!SWIG_IsOK(res1)) {
   19685           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_tileindex_get" "', argument " "1"" of type '" "resultObj *""'"); 
   19686             :   }
   19687           0 :   arg1 = (resultObj *)(argp1);
   19688           0 :   result = (int) ((arg1)->tileindex);
   19689             :   resultobj = SWIG_From_int((int)(result));
   19690           0 :   return resultobj;
   19691           0 : fail:
   19692             :   return NULL;
   19693             : }
   19694             : 
   19695             : 
   19696           0 : SWIGINTERN PyObject *_wrap_resultObj_resultindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19697             :   PyObject *resultobj = 0;
   19698             :   resultObj *arg1 = (resultObj *) 0 ;
   19699           0 :   void *argp1 = 0 ;
   19700             :   int res1 = 0 ;
   19701           0 :   PyObject * obj0 = 0 ;
   19702             :   int result;
   19703             :   
   19704           0 :   if (!PyArg_ParseTuple(args,(char *)"O:resultObj_resultindex_get",&obj0)) SWIG_fail;
   19705           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 |  0 );
   19706           0 :   if (!SWIG_IsOK(res1)) {
   19707           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_resultindex_get" "', argument " "1"" of type '" "resultObj *""'"); 
   19708             :   }
   19709           0 :   arg1 = (resultObj *)(argp1);
   19710           0 :   result = (int) ((arg1)->resultindex);
   19711             :   resultobj = SWIG_From_int((int)(result));
   19712           0 :   return resultobj;
   19713           0 : fail:
   19714             :   return NULL;
   19715             : }
   19716             : 
   19717             : 
   19718           0 : SWIGINTERN PyObject *_wrap_resultObj_classindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19719             :   PyObject *resultobj = 0;
   19720             :   resultObj *arg1 = (resultObj *) 0 ;
   19721           0 :   void *argp1 = 0 ;
   19722             :   int res1 = 0 ;
   19723           0 :   PyObject * obj0 = 0 ;
   19724             :   int result;
   19725             :   
   19726           0 :   if (!PyArg_ParseTuple(args,(char *)"O:resultObj_classindex_get",&obj0)) SWIG_fail;
   19727           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 |  0 );
   19728           0 :   if (!SWIG_IsOK(res1)) {
   19729           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_classindex_get" "', argument " "1"" of type '" "resultObj *""'"); 
   19730             :   }
   19731           0 :   arg1 = (resultObj *)(argp1);
   19732           0 :   result = (int) ((arg1)->classindex);
   19733             :   resultobj = SWIG_From_int((int)(result));
   19734           0 :   return resultobj;
   19735           0 : fail:
   19736             :   return NULL;
   19737             : }
   19738             : 
   19739             : 
   19740           0 : SWIGINTERN PyObject *_wrap_new_resultObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19741             :   PyObject *resultobj = 0;
   19742             :   long arg1 ;
   19743             :   long val1 ;
   19744             :   int ecode1 = 0 ;
   19745           0 :   PyObject * obj0 = 0 ;
   19746             :   resultObj *result = 0 ;
   19747             :   
   19748           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_resultObj",&obj0)) SWIG_fail;
   19749           0 :   ecode1 = SWIG_AsVal_long(obj0, &val1);
   19750           0 :   if (!SWIG_IsOK(ecode1)) {
   19751           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_resultObj" "', argument " "1"" of type '" "long""'");
   19752             :   } 
   19753           0 :   arg1 = (long)(val1);
   19754             :   {
   19755             :     result = (resultObj *)new_resultObj(arg1); {
   19756           0 :       errorObj *ms_error = msGetErrorObj();
   19757             :       
   19758           0 :       switch(ms_error->code) {
   19759             :       case MS_NOERR:
   19760             :         break;
   19761           0 :       case MS_NOTFOUND:
   19762           0 :         msResetErrorList();
   19763           0 :         break;
   19764             :       case -1:
   19765             :         break;
   19766           0 :       case MS_IOERR:
   19767           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19768           0 :           _raise_ms_exception();
   19769           0 :           msResetErrorList();
   19770           0 :           return NULL;
   19771             :         }
   19772             :       default:
   19773           0 :         _raise_ms_exception();
   19774           0 :         msResetErrorList();
   19775           0 :         return NULL;
   19776             :       }
   19777             :       
   19778             :     }
   19779             :   }
   19780           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultObj, SWIG_POINTER_NEW |  0 );
   19781           0 :   return resultobj;
   19782           0 : fail:
   19783             :   return NULL;
   19784             : }
   19785             : 
   19786             : 
   19787           0 : SWIGINTERN PyObject *_wrap_delete_resultObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19788             :   PyObject *resultobj = 0;
   19789             :   resultObj *arg1 = (resultObj *) 0 ;
   19790           0 :   void *argp1 = 0 ;
   19791             :   int res1 = 0 ;
   19792           0 :   PyObject * obj0 = 0 ;
   19793             :   
   19794           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_resultObj",&obj0)) SWIG_fail;
   19795           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, SWIG_POINTER_DISOWN |  0 );
   19796           0 :   if (!SWIG_IsOK(res1)) {
   19797           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_resultObj" "', argument " "1"" of type '" "resultObj *""'"); 
   19798             :   }
   19799           0 :   arg1 = (resultObj *)(argp1);
   19800             :   {
   19801             :     delete_resultObj(arg1); {
   19802           0 :       errorObj *ms_error = msGetErrorObj();
   19803             :       
   19804           0 :       switch(ms_error->code) {
   19805             :       case MS_NOERR:
   19806             :         break;
   19807           0 :       case MS_NOTFOUND:
   19808           0 :         msResetErrorList();
   19809           0 :         break;
   19810             :       case -1:
   19811             :         break;
   19812           0 :       case MS_IOERR:
   19813           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19814           0 :           _raise_ms_exception();
   19815           0 :           msResetErrorList();
   19816           0 :           return NULL;
   19817             :         }
   19818             :       default:
   19819           0 :         _raise_ms_exception();
   19820           0 :         msResetErrorList();
   19821           0 :         return NULL;
   19822             :       }
   19823             :       
   19824             :     }
   19825             :   }
   19826             :   resultobj = SWIG_Py_Void();
   19827           0 :   return resultobj;
   19828           0 : fail:
   19829             :   return NULL;
   19830             : }
   19831             : 
   19832             : 
   19833           1 : SWIGINTERN PyObject *resultObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19834             :   PyObject *obj;
   19835           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   19836           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_resultObj, SWIG_NewClientData(obj));
   19837           1 :   return SWIG_Py_Void();
   19838             : }
   19839             : 
   19840           1 : SWIGINTERN PyObject *_wrap_resultCacheObj_numresults_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19841             :   PyObject *resultobj = 0;
   19842             :   resultCacheObj *arg1 = (resultCacheObj *) 0 ;
   19843           1 :   void *argp1 = 0 ;
   19844             :   int res1 = 0 ;
   19845           1 :   PyObject * obj0 = 0 ;
   19846             :   int result;
   19847             :   
   19848           1 :   if (!PyArg_ParseTuple(args,(char *)"O:resultCacheObj_numresults_get",&obj0)) SWIG_fail;
   19849           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 |  0 );
   19850           1 :   if (!SWIG_IsOK(res1)) {
   19851           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_numresults_get" "', argument " "1"" of type '" "resultCacheObj *""'"); 
   19852             :   }
   19853           1 :   arg1 = (resultCacheObj *)(argp1);
   19854           1 :   result = (int) ((arg1)->numresults);
   19855             :   resultobj = SWIG_From_int((int)(result));
   19856           1 :   return resultobj;
   19857           0 : fail:
   19858             :   return NULL;
   19859             : }
   19860             : 
   19861             : 
   19862           1 : SWIGINTERN PyObject *_wrap_resultCacheObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19863             :   PyObject *resultobj = 0;
   19864             :   resultCacheObj *arg1 = (resultCacheObj *) 0 ;
   19865           1 :   void *argp1 = 0 ;
   19866             :   int res1 = 0 ;
   19867           1 :   PyObject * obj0 = 0 ;
   19868             :   rectObj *result = 0 ;
   19869             :   
   19870           1 :   if (!PyArg_ParseTuple(args,(char *)"O:resultCacheObj_bounds_get",&obj0)) SWIG_fail;
   19871           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 |  0 );
   19872           1 :   if (!SWIG_IsOK(res1)) {
   19873           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_bounds_get" "', argument " "1"" of type '" "resultCacheObj *""'"); 
   19874             :   }
   19875           1 :   arg1 = (resultCacheObj *)(argp1);
   19876           1 :   result = (rectObj *)& ((arg1)->bounds);
   19877           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   19878           1 :   return resultobj;
   19879           0 : fail:
   19880             :   return NULL;
   19881             : }
   19882             : 
   19883             : 
   19884           0 : SWIGINTERN PyObject *_wrap_resultCacheObj_usegetshape_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19885             :   PyObject *resultobj = 0;
   19886             :   resultCacheObj *arg1 = (resultCacheObj *) 0 ;
   19887             :   int arg2 ;
   19888           0 :   void *argp1 = 0 ;
   19889             :   int res1 = 0 ;
   19890             :   int val2 ;
   19891             :   int ecode2 = 0 ;
   19892           0 :   PyObject * obj0 = 0 ;
   19893           0 :   PyObject * obj1 = 0 ;
   19894             :   
   19895           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:resultCacheObj_usegetshape_set",&obj0,&obj1)) SWIG_fail;
   19896           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 |  0 );
   19897           0 :   if (!SWIG_IsOK(res1)) {
   19898           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_usegetshape_set" "', argument " "1"" of type '" "resultCacheObj *""'"); 
   19899             :   }
   19900           0 :   arg1 = (resultCacheObj *)(argp1);
   19901           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   19902           0 :   if (!SWIG_IsOK(ecode2)) {
   19903           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "resultCacheObj_usegetshape_set" "', argument " "2"" of type '" "int""'");
   19904             :   } 
   19905             :   arg2 = (int)(val2);
   19906           0 :   if (arg1) (arg1)->usegetshape = arg2;
   19907             :   resultobj = SWIG_Py_Void();
   19908           0 :   return resultobj;
   19909           0 : fail:
   19910             :   return NULL;
   19911             : }
   19912             : 
   19913             : 
   19914           0 : SWIGINTERN PyObject *_wrap_resultCacheObj_usegetshape_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19915             :   PyObject *resultobj = 0;
   19916             :   resultCacheObj *arg1 = (resultCacheObj *) 0 ;
   19917           0 :   void *argp1 = 0 ;
   19918             :   int res1 = 0 ;
   19919           0 :   PyObject * obj0 = 0 ;
   19920             :   int result;
   19921             :   
   19922           0 :   if (!PyArg_ParseTuple(args,(char *)"O:resultCacheObj_usegetshape_get",&obj0)) SWIG_fail;
   19923           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 |  0 );
   19924           0 :   if (!SWIG_IsOK(res1)) {
   19925           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_usegetshape_get" "', argument " "1"" of type '" "resultCacheObj *""'"); 
   19926             :   }
   19927           0 :   arg1 = (resultCacheObj *)(argp1);
   19928           0 :   result = (int) ((arg1)->usegetshape);
   19929             :   resultobj = SWIG_From_int((int)(result));
   19930           0 :   return resultobj;
   19931           0 : fail:
   19932             :   return NULL;
   19933             : }
   19934             : 
   19935             : 
   19936           1 : SWIGINTERN PyObject *_wrap_resultCacheObj_getResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19937             :   PyObject *resultobj = 0;
   19938             :   resultCacheObj *arg1 = (resultCacheObj *) 0 ;
   19939             :   int arg2 ;
   19940           1 :   void *argp1 = 0 ;
   19941             :   int res1 = 0 ;
   19942             :   int val2 ;
   19943             :   int ecode2 = 0 ;
   19944           1 :   PyObject * obj0 = 0 ;
   19945           1 :   PyObject * obj1 = 0 ;
   19946             :   resultObj *result = 0 ;
   19947             :   
   19948           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:resultCacheObj_getResult",&obj0,&obj1)) SWIG_fail;
   19949           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 |  0 );
   19950           1 :   if (!SWIG_IsOK(res1)) {
   19951           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_getResult" "', argument " "1"" of type '" "resultCacheObj *""'"); 
   19952             :   }
   19953           1 :   arg1 = (resultCacheObj *)(argp1);
   19954           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   19955           1 :   if (!SWIG_IsOK(ecode2)) {
   19956           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "resultCacheObj_getResult" "', argument " "2"" of type '" "int""'");
   19957             :   } 
   19958             :   arg2 = (int)(val2);
   19959             :   {
   19960             :     result = (resultObj *)resultCacheObj_getResult(arg1,arg2); {
   19961           1 :       errorObj *ms_error = msGetErrorObj();
   19962             :       
   19963           1 :       switch(ms_error->code) {
   19964             :       case MS_NOERR:
   19965             :         break;
   19966           0 :       case MS_NOTFOUND:
   19967           0 :         msResetErrorList();
   19968           0 :         break;
   19969             :       case -1:
   19970             :         break;
   19971           0 :       case MS_IOERR:
   19972           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   19973           0 :           _raise_ms_exception();
   19974           0 :           msResetErrorList();
   19975           0 :           return NULL;
   19976             :         }
   19977             :       default:
   19978           0 :         _raise_ms_exception();
   19979           0 :         msResetErrorList();
   19980           0 :         return NULL;
   19981             :       }
   19982             :       
   19983             :     }
   19984             :   }
   19985           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultObj, 0 |  0 );
   19986           1 :   return resultobj;
   19987           0 : fail:
   19988             :   return NULL;
   19989             : }
   19990             : 
   19991             : 
   19992           0 : SWIGINTERN PyObject *_wrap_new_resultCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   19993             :   PyObject *resultobj = 0;
   19994             :   resultCacheObj *result = 0 ;
   19995             :   
   19996           0 :   if (!PyArg_ParseTuple(args,(char *)":new_resultCacheObj")) SWIG_fail;
   19997             :   {
   19998           0 :     result = (resultCacheObj *)calloc(1, sizeof(resultCacheObj)); {
   19999           0 :       errorObj *ms_error = msGetErrorObj();
   20000             :       
   20001           0 :       switch(ms_error->code) {
   20002             :       case MS_NOERR:
   20003             :         break;
   20004           0 :       case MS_NOTFOUND:
   20005           0 :         msResetErrorList();
   20006           0 :         break;
   20007             :       case -1:
   20008             :         break;
   20009           0 :       case MS_IOERR:
   20010           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20011           0 :           _raise_ms_exception();
   20012           0 :           msResetErrorList();
   20013           0 :           return NULL;
   20014             :         }
   20015             :       default:
   20016           0 :         _raise_ms_exception();
   20017           0 :         msResetErrorList();
   20018           0 :         return NULL;
   20019             :       }
   20020             :       
   20021             :     }
   20022             :   }
   20023           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultCacheObj, SWIG_POINTER_NEW |  0 );
   20024           0 :   return resultobj;
   20025           0 : fail:
   20026             :   return NULL;
   20027             : }
   20028             : 
   20029             : 
   20030           0 : SWIGINTERN PyObject *_wrap_delete_resultCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20031             :   PyObject *resultobj = 0;
   20032             :   resultCacheObj *arg1 = (resultCacheObj *) 0 ;
   20033           0 :   void *argp1 = 0 ;
   20034             :   int res1 = 0 ;
   20035           0 :   PyObject * obj0 = 0 ;
   20036             :   
   20037           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_resultCacheObj",&obj0)) SWIG_fail;
   20038           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, SWIG_POINTER_DISOWN |  0 );
   20039           0 :   if (!SWIG_IsOK(res1)) {
   20040           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_resultCacheObj" "', argument " "1"" of type '" "resultCacheObj *""'"); 
   20041             :   }
   20042           0 :   arg1 = (resultCacheObj *)(argp1);
   20043             :   {
   20044           0 :     free((char *) arg1); {
   20045           0 :       errorObj *ms_error = msGetErrorObj();
   20046             :       
   20047           0 :       switch(ms_error->code) {
   20048             :       case MS_NOERR:
   20049             :         break;
   20050           0 :       case MS_NOTFOUND:
   20051           0 :         msResetErrorList();
   20052           0 :         break;
   20053             :       case -1:
   20054             :         break;
   20055           0 :       case MS_IOERR:
   20056           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20057           0 :           _raise_ms_exception();
   20058           0 :           msResetErrorList();
   20059           0 :           return NULL;
   20060             :         }
   20061             :       default:
   20062           0 :         _raise_ms_exception();
   20063           0 :         msResetErrorList();
   20064           0 :         return NULL;
   20065             :       }
   20066             :       
   20067             :     }
   20068             :   }
   20069             :   resultobj = SWIG_Py_Void();
   20070           0 :   return resultobj;
   20071           0 : fail:
   20072             :   return NULL;
   20073             : }
   20074             : 
   20075             : 
   20076           1 : SWIGINTERN PyObject *resultCacheObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20077             :   PyObject *obj;
   20078           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   20079           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_resultCacheObj, SWIG_NewClientData(obj));
   20080           1 :   return SWIG_Py_Void();
   20081             : }
   20082             : 
   20083           0 : SWIGINTERN PyObject *_wrap_symbolSetObj_filename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20084             :   PyObject *resultobj = 0;
   20085             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20086             :   char *arg2 = (char *) 0 ;
   20087           0 :   void *argp1 = 0 ;
   20088             :   int res1 = 0 ;
   20089             :   int res2 ;
   20090           0 :   char *buf2 = 0 ;
   20091           0 :   int alloc2 = 0 ;
   20092           0 :   PyObject * obj0 = 0 ;
   20093           0 :   PyObject * obj1 = 0 ;
   20094             :   
   20095           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_filename_set",&obj0,&obj1)) SWIG_fail;
   20096           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20097           0 :   if (!SWIG_IsOK(res1)) {
   20098           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_filename_set" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20099             :   }
   20100           0 :   arg1 = (symbolSetObj *)(argp1);
   20101           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   20102           0 :   if (!SWIG_IsOK(res2)) {
   20103           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_filename_set" "', argument " "2"" of type '" "char *""'");
   20104             :   }
   20105           0 :   arg2 = (char *)(buf2);
   20106             :   {
   20107           0 :     if (arg1->filename) free((char*)arg1->filename);
   20108           0 :     if (arg2) {
   20109           0 :       arg1->filename = (char *) malloc(strlen(arg2)+1);
   20110             :       strcpy((char*)arg1->filename,arg2);
   20111             :     } else {
   20112           0 :       arg1->filename = 0;
   20113             :     }
   20114             :   }
   20115             :   resultobj = SWIG_Py_Void();
   20116           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20117             :   return resultobj;
   20118           0 : fail:
   20119           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20120             :   return NULL;
   20121             : }
   20122             : 
   20123             : 
   20124           0 : SWIGINTERN PyObject *_wrap_symbolSetObj_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20125             :   PyObject *resultobj = 0;
   20126             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20127           0 :   void *argp1 = 0 ;
   20128             :   int res1 = 0 ;
   20129           0 :   PyObject * obj0 = 0 ;
   20130             :   char *result = 0 ;
   20131             :   
   20132           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_filename_get",&obj0)) SWIG_fail;
   20133           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20134           0 :   if (!SWIG_IsOK(res1)) {
   20135           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_filename_get" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20136             :   }
   20137           0 :   arg1 = (symbolSetObj *)(argp1);
   20138           0 :   result = (char *) ((arg1)->filename);
   20139           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   20140           0 :   return resultobj;
   20141           0 : fail:
   20142             :   return NULL;
   20143             : }
   20144             : 
   20145             : 
   20146           0 : SWIGINTERN PyObject *_wrap_symbolSetObj_imagecachesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20147             :   PyObject *resultobj = 0;
   20148             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20149             :   int arg2 ;
   20150           0 :   void *argp1 = 0 ;
   20151             :   int res1 = 0 ;
   20152             :   int val2 ;
   20153             :   int ecode2 = 0 ;
   20154           0 :   PyObject * obj0 = 0 ;
   20155           0 :   PyObject * obj1 = 0 ;
   20156             :   
   20157           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_imagecachesize_set",&obj0,&obj1)) SWIG_fail;
   20158           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20159           0 :   if (!SWIG_IsOK(res1)) {
   20160           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_imagecachesize_set" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20161             :   }
   20162           0 :   arg1 = (symbolSetObj *)(argp1);
   20163           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   20164           0 :   if (!SWIG_IsOK(ecode2)) {
   20165           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolSetObj_imagecachesize_set" "', argument " "2"" of type '" "int""'");
   20166             :   } 
   20167             :   arg2 = (int)(val2);
   20168           0 :   if (arg1) (arg1)->imagecachesize = arg2;
   20169             :   resultobj = SWIG_Py_Void();
   20170           0 :   return resultobj;
   20171           0 : fail:
   20172             :   return NULL;
   20173             : }
   20174             : 
   20175             : 
   20176           0 : SWIGINTERN PyObject *_wrap_symbolSetObj_imagecachesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20177             :   PyObject *resultobj = 0;
   20178             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20179           0 :   void *argp1 = 0 ;
   20180             :   int res1 = 0 ;
   20181           0 :   PyObject * obj0 = 0 ;
   20182             :   int result;
   20183             :   
   20184           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_imagecachesize_get",&obj0)) SWIG_fail;
   20185           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20186           0 :   if (!SWIG_IsOK(res1)) {
   20187           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_imagecachesize_get" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20188             :   }
   20189           0 :   arg1 = (symbolSetObj *)(argp1);
   20190           0 :   result = (int) ((arg1)->imagecachesize);
   20191             :   resultobj = SWIG_From_int((int)(result));
   20192           0 :   return resultobj;
   20193           0 : fail:
   20194             :   return NULL;
   20195             : }
   20196             : 
   20197             : 
   20198           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_numsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20199             :   PyObject *resultobj = 0;
   20200             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20201           1 :   void *argp1 = 0 ;
   20202             :   int res1 = 0 ;
   20203           1 :   PyObject * obj0 = 0 ;
   20204             :   int result;
   20205             :   
   20206           1 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_numsymbols_get",&obj0)) SWIG_fail;
   20207           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20208           1 :   if (!SWIG_IsOK(res1)) {
   20209           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_numsymbols_get" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20210             :   }
   20211           1 :   arg1 = (symbolSetObj *)(argp1);
   20212           1 :   result = (int) ((arg1)->numsymbols);
   20213             :   resultobj = SWIG_From_int((int)(result));
   20214           1 :   return resultobj;
   20215           0 : fail:
   20216             :   return NULL;
   20217             : }
   20218             : 
   20219             : 
   20220           0 : SWIGINTERN PyObject *_wrap_symbolSetObj_maxsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20221             :   PyObject *resultobj = 0;
   20222             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20223           0 :   void *argp1 = 0 ;
   20224             :   int res1 = 0 ;
   20225           0 :   PyObject * obj0 = 0 ;
   20226             :   int result;
   20227             :   
   20228           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_maxsymbols_get",&obj0)) SWIG_fail;
   20229           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20230           0 :   if (!SWIG_IsOK(res1)) {
   20231           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_maxsymbols_get" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20232             :   }
   20233           0 :   arg1 = (symbolSetObj *)(argp1);
   20234           0 :   result = (int) ((arg1)->maxsymbols);
   20235             :   resultobj = SWIG_From_int((int)(result));
   20236           0 :   return resultobj;
   20237           0 : fail:
   20238             :   return NULL;
   20239             : }
   20240             : 
   20241             : 
   20242           1 : SWIGINTERN PyObject *_wrap_new_symbolSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20243             :   PyObject *resultobj = 0;
   20244             :   char *arg1 = (char *) NULL ;
   20245             :   int res1 ;
   20246           1 :   char *buf1 = 0 ;
   20247           1 :   int alloc1 = 0 ;
   20248           1 :   PyObject * obj0 = 0 ;
   20249             :   symbolSetObj *result = 0 ;
   20250             :   
   20251           1 :   if (!PyArg_ParseTuple(args,(char *)"|O:new_symbolSetObj",&obj0)) SWIG_fail;
   20252           1 :   if (obj0) {
   20253           1 :     res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   20254           1 :     if (!SWIG_IsOK(res1)) {
   20255           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_symbolSetObj" "', argument " "1"" of type '" "char const *""'");
   20256             :     }
   20257           1 :     arg1 = (char *)(buf1);
   20258             :   }
   20259             :   {
   20260           1 :     result = (symbolSetObj *)new_symbolSetObj((char const *)arg1); {
   20261           1 :       errorObj *ms_error = msGetErrorObj();
   20262             :       
   20263           1 :       switch(ms_error->code) {
   20264             :       case MS_NOERR:
   20265             :         break;
   20266           0 :       case MS_NOTFOUND:
   20267           0 :         msResetErrorList();
   20268           0 :         break;
   20269             :       case -1:
   20270             :         break;
   20271           0 :       case MS_IOERR:
   20272           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20273           0 :           _raise_ms_exception();
   20274           0 :           msResetErrorList();
   20275           0 :           return NULL;
   20276             :         }
   20277             :       default:
   20278           0 :         _raise_ms_exception();
   20279           0 :         msResetErrorList();
   20280           0 :         return NULL;
   20281             :       }
   20282             :       
   20283             :     }
   20284             :   }
   20285           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolSetObj, SWIG_POINTER_NEW |  0 );
   20286           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   20287             :   return resultobj;
   20288           0 : fail:
   20289           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   20290             :   return NULL;
   20291             : }
   20292             : 
   20293             : 
   20294           1 : SWIGINTERN PyObject *_wrap_delete_symbolSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20295             :   PyObject *resultobj = 0;
   20296             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20297           1 :   void *argp1 = 0 ;
   20298             :   int res1 = 0 ;
   20299           1 :   PyObject * obj0 = 0 ;
   20300             :   
   20301           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_symbolSetObj",&obj0)) SWIG_fail;
   20302           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, SWIG_POINTER_DISOWN |  0 );
   20303           1 :   if (!SWIG_IsOK(res1)) {
   20304           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_symbolSetObj" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20305             :   }
   20306           1 :   arg1 = (symbolSetObj *)(argp1);
   20307             :   {
   20308           1 :     delete_symbolSetObj(arg1); {
   20309           1 :       errorObj *ms_error = msGetErrorObj();
   20310             :       
   20311           1 :       switch(ms_error->code) {
   20312             :       case MS_NOERR:
   20313             :         break;
   20314           0 :       case MS_NOTFOUND:
   20315           0 :         msResetErrorList();
   20316           0 :         break;
   20317             :       case -1:
   20318             :         break;
   20319           0 :       case MS_IOERR:
   20320           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20321           0 :           _raise_ms_exception();
   20322           0 :           msResetErrorList();
   20323           0 :           return NULL;
   20324             :         }
   20325             :       default:
   20326           0 :         _raise_ms_exception();
   20327           0 :         msResetErrorList();
   20328           0 :         return NULL;
   20329             :       }
   20330             :       
   20331             :     }
   20332             :   }
   20333             :   resultobj = SWIG_Py_Void();
   20334           1 :   return resultobj;
   20335           0 : fail:
   20336             :   return NULL;
   20337             : }
   20338             : 
   20339             : 
   20340           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_getSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20341             :   PyObject *resultobj = 0;
   20342             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20343             :   int arg2 ;
   20344           1 :   void *argp1 = 0 ;
   20345             :   int res1 = 0 ;
   20346             :   int val2 ;
   20347             :   int ecode2 = 0 ;
   20348           1 :   PyObject * obj0 = 0 ;
   20349           1 :   PyObject * obj1 = 0 ;
   20350             :   symbolObj *result = 0 ;
   20351             :   
   20352           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_getSymbol",&obj0,&obj1)) SWIG_fail;
   20353           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20354           1 :   if (!SWIG_IsOK(res1)) {
   20355           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_getSymbol" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20356             :   }
   20357           1 :   arg1 = (symbolSetObj *)(argp1);
   20358           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   20359           1 :   if (!SWIG_IsOK(ecode2)) {
   20360           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolSetObj_getSymbol" "', argument " "2"" of type '" "int""'");
   20361             :   } 
   20362             :   arg2 = (int)(val2);
   20363             :   {
   20364             :     result = (symbolObj *)symbolSetObj_getSymbol(arg1,arg2); {
   20365           1 :       errorObj *ms_error = msGetErrorObj();
   20366             :       
   20367           1 :       switch(ms_error->code) {
   20368             :       case MS_NOERR:
   20369             :         break;
   20370           0 :       case MS_NOTFOUND:
   20371           0 :         msResetErrorList();
   20372           0 :         break;
   20373             :       case -1:
   20374             :         break;
   20375           0 :       case MS_IOERR:
   20376           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20377           0 :           _raise_ms_exception();
   20378           0 :           msResetErrorList();
   20379           0 :           return NULL;
   20380             :         }
   20381             :       default:
   20382           0 :         _raise_ms_exception();
   20383           0 :         msResetErrorList();
   20384           0 :         return NULL;
   20385             :       }
   20386             :       
   20387             :     }
   20388             :   }
   20389           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_OWN |  0 );
   20390           1 :   return resultobj;
   20391           0 : fail:
   20392             :   return NULL;
   20393             : }
   20394             : 
   20395             : 
   20396           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_getSymbolByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20397             :   PyObject *resultobj = 0;
   20398             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20399             :   char *arg2 = (char *) 0 ;
   20400           1 :   void *argp1 = 0 ;
   20401             :   int res1 = 0 ;
   20402             :   int res2 ;
   20403           1 :   char *buf2 = 0 ;
   20404           1 :   int alloc2 = 0 ;
   20405           1 :   PyObject * obj0 = 0 ;
   20406           1 :   PyObject * obj1 = 0 ;
   20407             :   symbolObj *result = 0 ;
   20408             :   
   20409           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_getSymbolByName",&obj0,&obj1)) SWIG_fail;
   20410           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20411           1 :   if (!SWIG_IsOK(res1)) {
   20412           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_getSymbolByName" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20413             :   }
   20414           1 :   arg1 = (symbolSetObj *)(argp1);
   20415           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   20416           1 :   if (!SWIG_IsOK(res2)) {
   20417           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_getSymbolByName" "', argument " "2"" of type '" "char *""'");
   20418             :   }
   20419           1 :   arg2 = (char *)(buf2);
   20420             :   {
   20421           1 :     result = (symbolObj *)symbolSetObj_getSymbolByName(arg1,arg2); {
   20422           1 :       errorObj *ms_error = msGetErrorObj();
   20423             :       
   20424           1 :       switch(ms_error->code) {
   20425             :       case MS_NOERR:
   20426             :         break;
   20427           0 :       case MS_NOTFOUND:
   20428           0 :         msResetErrorList();
   20429           0 :         break;
   20430             :       case -1:
   20431             :         break;
   20432           0 :       case MS_IOERR:
   20433           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20434           0 :           _raise_ms_exception();
   20435           0 :           msResetErrorList();
   20436           0 :           return NULL;
   20437             :         }
   20438             :       default:
   20439           0 :         _raise_ms_exception();
   20440           0 :         msResetErrorList();
   20441           0 :         return NULL;
   20442             :       }
   20443             :       
   20444             :     }
   20445             :   }
   20446           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_OWN |  0 );
   20447           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20448             :   return resultobj;
   20449           0 : fail:
   20450           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20451             :   return NULL;
   20452             : }
   20453             : 
   20454             : 
   20455           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20456             :   PyObject *resultobj = 0;
   20457             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20458             :   char *arg2 = (char *) 0 ;
   20459           1 :   void *argp1 = 0 ;
   20460             :   int res1 = 0 ;
   20461             :   int res2 ;
   20462           1 :   char *buf2 = 0 ;
   20463           1 :   int alloc2 = 0 ;
   20464           1 :   PyObject * obj0 = 0 ;
   20465           1 :   PyObject * obj1 = 0 ;
   20466             :   int result;
   20467             :   
   20468           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_index",&obj0,&obj1)) SWIG_fail;
   20469           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20470           1 :   if (!SWIG_IsOK(res1)) {
   20471           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_index" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20472             :   }
   20473           1 :   arg1 = (symbolSetObj *)(argp1);
   20474           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   20475           1 :   if (!SWIG_IsOK(res2)) {
   20476           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_index" "', argument " "2"" of type '" "char *""'");
   20477             :   }
   20478           1 :   arg2 = (char *)(buf2);
   20479             :   {
   20480             :     result = (int)symbolSetObj_index(arg1,arg2); {
   20481           1 :       errorObj *ms_error = msGetErrorObj();
   20482             :       
   20483           1 :       switch(ms_error->code) {
   20484             :       case MS_NOERR:
   20485             :         break;
   20486           0 :       case MS_NOTFOUND:
   20487           0 :         msResetErrorList();
   20488           0 :         break;
   20489             :       case -1:
   20490             :         break;
   20491           0 :       case MS_IOERR:
   20492           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20493           0 :           _raise_ms_exception();
   20494           0 :           msResetErrorList();
   20495           0 :           return NULL;
   20496             :         }
   20497             :       default:
   20498           0 :         _raise_ms_exception();
   20499           0 :         msResetErrorList();
   20500           0 :         return NULL;
   20501             :       }
   20502             :       
   20503             :     }
   20504             :   }
   20505             :   resultobj = SWIG_From_int((int)(result));
   20506           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20507             :   return resultobj;
   20508           0 : fail:
   20509           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20510             :   return NULL;
   20511             : }
   20512             : 
   20513             : 
   20514           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_appendSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20515             :   PyObject *resultobj = 0;
   20516             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20517             :   symbolObj *arg2 = (symbolObj *) 0 ;
   20518           1 :   void *argp1 = 0 ;
   20519             :   int res1 = 0 ;
   20520           1 :   void *argp2 = 0 ;
   20521             :   int res2 = 0 ;
   20522           1 :   PyObject * obj0 = 0 ;
   20523           1 :   PyObject * obj1 = 0 ;
   20524             :   int result;
   20525             :   
   20526           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_appendSymbol",&obj0,&obj1)) SWIG_fail;
   20527           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20528           1 :   if (!SWIG_IsOK(res1)) {
   20529           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_appendSymbol" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20530             :   }
   20531           1 :   arg1 = (symbolSetObj *)(argp1);
   20532           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_symbolObj, 0 |  0 );
   20533           1 :   if (!SWIG_IsOK(res2)) {
   20534           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_appendSymbol" "', argument " "2"" of type '" "symbolObj *""'"); 
   20535             :   }
   20536           1 :   arg2 = (symbolObj *)(argp2);
   20537             :   {
   20538             :     result = (int)symbolSetObj_appendSymbol(arg1,arg2); {
   20539           1 :       errorObj *ms_error = msGetErrorObj();
   20540             :       
   20541           1 :       switch(ms_error->code) {
   20542             :       case MS_NOERR:
   20543             :         break;
   20544           0 :       case MS_NOTFOUND:
   20545           0 :         msResetErrorList();
   20546           0 :         break;
   20547             :       case -1:
   20548             :         break;
   20549           0 :       case MS_IOERR:
   20550           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20551           0 :           _raise_ms_exception();
   20552           0 :           msResetErrorList();
   20553           0 :           return NULL;
   20554             :         }
   20555             :       default:
   20556           0 :         _raise_ms_exception();
   20557           0 :         msResetErrorList();
   20558           0 :         return NULL;
   20559             :       }
   20560             :       
   20561             :     }
   20562             :   }
   20563             :   resultobj = SWIG_From_int((int)(result));
   20564           1 :   return resultobj;
   20565           0 : fail:
   20566             :   return NULL;
   20567             : }
   20568             : 
   20569             : 
   20570           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_removeSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20571             :   PyObject *resultobj = 0;
   20572             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20573             :   int arg2 ;
   20574           1 :   void *argp1 = 0 ;
   20575             :   int res1 = 0 ;
   20576             :   int val2 ;
   20577             :   int ecode2 = 0 ;
   20578           1 :   PyObject * obj0 = 0 ;
   20579           1 :   PyObject * obj1 = 0 ;
   20580             :   symbolObj *result = 0 ;
   20581             :   
   20582           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_removeSymbol",&obj0,&obj1)) SWIG_fail;
   20583           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20584           1 :   if (!SWIG_IsOK(res1)) {
   20585           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_removeSymbol" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20586             :   }
   20587           1 :   arg1 = (symbolSetObj *)(argp1);
   20588           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   20589           1 :   if (!SWIG_IsOK(ecode2)) {
   20590           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolSetObj_removeSymbol" "', argument " "2"" of type '" "int""'");
   20591             :   } 
   20592             :   arg2 = (int)(val2);
   20593             :   {
   20594           1 :     result = (symbolObj *)symbolSetObj_removeSymbol(arg1,arg2); {
   20595           1 :       errorObj *ms_error = msGetErrorObj();
   20596             :       
   20597           1 :       switch(ms_error->code) {
   20598             :       case MS_NOERR:
   20599             :         break;
   20600           0 :       case MS_NOTFOUND:
   20601           0 :         msResetErrorList();
   20602           0 :         break;
   20603             :       case -1:
   20604             :         break;
   20605           0 :       case MS_IOERR:
   20606           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20607           0 :           _raise_ms_exception();
   20608           0 :           msResetErrorList();
   20609           0 :           return NULL;
   20610             :         }
   20611             :       default:
   20612           0 :         _raise_ms_exception();
   20613           0 :         msResetErrorList();
   20614           0 :         return NULL;
   20615             :       }
   20616             :       
   20617             :     }
   20618             :   }
   20619           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_OWN |  0 );
   20620           1 :   return resultobj;
   20621           0 : fail:
   20622             :   return NULL;
   20623             : }
   20624             : 
   20625             : 
   20626           1 : SWIGINTERN PyObject *_wrap_symbolSetObj_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20627             :   PyObject *resultobj = 0;
   20628             :   symbolSetObj *arg1 = (symbolSetObj *) 0 ;
   20629             :   char *arg2 = (char *) 0 ;
   20630           1 :   void *argp1 = 0 ;
   20631             :   int res1 = 0 ;
   20632             :   int res2 ;
   20633           1 :   char *buf2 = 0 ;
   20634           1 :   int alloc2 = 0 ;
   20635           1 :   PyObject * obj0 = 0 ;
   20636           1 :   PyObject * obj1 = 0 ;
   20637             :   int result;
   20638             :   
   20639           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_save",&obj0,&obj1)) SWIG_fail;
   20640           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 |  0 );
   20641           1 :   if (!SWIG_IsOK(res1)) {
   20642           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_save" "', argument " "1"" of type '" "symbolSetObj *""'"); 
   20643             :   }
   20644           1 :   arg1 = (symbolSetObj *)(argp1);
   20645           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   20646           1 :   if (!SWIG_IsOK(res2)) {
   20647           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_save" "', argument " "2"" of type '" "char const *""'");
   20648             :   }
   20649           1 :   arg2 = (char *)(buf2);
   20650             :   {
   20651             :     result = (int)symbolSetObj_save(arg1,(char const *)arg2); {
   20652           1 :       errorObj *ms_error = msGetErrorObj();
   20653             :       
   20654           1 :       switch(ms_error->code) {
   20655             :       case MS_NOERR:
   20656             :         break;
   20657           0 :       case MS_NOTFOUND:
   20658           0 :         msResetErrorList();
   20659           0 :         break;
   20660             :       case -1:
   20661             :         break;
   20662           0 :       case MS_IOERR:
   20663           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   20664           0 :           _raise_ms_exception();
   20665           0 :           msResetErrorList();
   20666           0 :           return NULL;
   20667             :         }
   20668             :       default:
   20669           1 :         _raise_ms_exception();
   20670           1 :         msResetErrorList();
   20671           1 :         return NULL;
   20672             :       }
   20673             :       
   20674             :     }
   20675             :   }
   20676             :   resultobj = SWIG_From_int((int)(result));
   20677           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20678             :   return resultobj;
   20679           0 : fail:
   20680           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20681             :   return NULL;
   20682             : }
   20683             : 
   20684             : 
   20685           1 : SWIGINTERN PyObject *symbolSetObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20686             :   PyObject *obj;
   20687           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   20688           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_symbolSetObj, SWIG_NewClientData(obj));
   20689           1 :   return SWIG_Py_Void();
   20690             : }
   20691             : 
   20692           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_extent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20693             :   PyObject *resultobj = 0;
   20694             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20695             :   rectObj *arg2 = (rectObj *) 0 ;
   20696           0 :   void *argp1 = 0 ;
   20697             :   int res1 = 0 ;
   20698           0 :   void *argp2 = 0 ;
   20699             :   int res2 = 0 ;
   20700           0 :   PyObject * obj0 = 0 ;
   20701           0 :   PyObject * obj1 = 0 ;
   20702             :   
   20703           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_extent_set",&obj0,&obj1)) SWIG_fail;
   20704           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20705           0 :   if (!SWIG_IsOK(res1)) {
   20706           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_extent_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20707             :   }
   20708           0 :   arg1 = (referenceMapObj *)(argp1);
   20709           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 |  0 );
   20710           0 :   if (!SWIG_IsOK(res2)) {
   20711           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_extent_set" "', argument " "2"" of type '" "rectObj *""'"); 
   20712             :   }
   20713           0 :   arg2 = (rectObj *)(argp2);
   20714           0 :   if (arg1) (arg1)->extent = *arg2;
   20715             :   resultobj = SWIG_Py_Void();
   20716           0 :   return resultobj;
   20717           0 : fail:
   20718             :   return NULL;
   20719             : }
   20720             : 
   20721             : 
   20722           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20723             :   PyObject *resultobj = 0;
   20724             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20725           0 :   void *argp1 = 0 ;
   20726             :   int res1 = 0 ;
   20727           0 :   PyObject * obj0 = 0 ;
   20728             :   rectObj *result = 0 ;
   20729             :   
   20730           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_extent_get",&obj0)) SWIG_fail;
   20731           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20732           0 :   if (!SWIG_IsOK(res1)) {
   20733           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_extent_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20734             :   }
   20735           0 :   arg1 = (referenceMapObj *)(argp1);
   20736           0 :   result = (rectObj *)& ((arg1)->extent);
   20737           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   20738           0 :   return resultobj;
   20739           0 : fail:
   20740             :   return NULL;
   20741             : }
   20742             : 
   20743             : 
   20744           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20745             :   PyObject *resultobj = 0;
   20746             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20747             :   int arg2 ;
   20748           0 :   void *argp1 = 0 ;
   20749             :   int res1 = 0 ;
   20750             :   int val2 ;
   20751             :   int ecode2 = 0 ;
   20752           0 :   PyObject * obj0 = 0 ;
   20753           0 :   PyObject * obj1 = 0 ;
   20754             :   
   20755           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_height_set",&obj0,&obj1)) SWIG_fail;
   20756           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20757           0 :   if (!SWIG_IsOK(res1)) {
   20758           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_height_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20759             :   }
   20760           0 :   arg1 = (referenceMapObj *)(argp1);
   20761           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   20762           0 :   if (!SWIG_IsOK(ecode2)) {
   20763           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_height_set" "', argument " "2"" of type '" "int""'");
   20764             :   } 
   20765             :   arg2 = (int)(val2);
   20766           0 :   if (arg1) (arg1)->height = arg2;
   20767             :   resultobj = SWIG_Py_Void();
   20768           0 :   return resultobj;
   20769           0 : fail:
   20770             :   return NULL;
   20771             : }
   20772             : 
   20773             : 
   20774           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20775             :   PyObject *resultobj = 0;
   20776             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20777           0 :   void *argp1 = 0 ;
   20778             :   int res1 = 0 ;
   20779           0 :   PyObject * obj0 = 0 ;
   20780             :   int result;
   20781             :   
   20782           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_height_get",&obj0)) SWIG_fail;
   20783           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20784           0 :   if (!SWIG_IsOK(res1)) {
   20785           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_height_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20786             :   }
   20787           0 :   arg1 = (referenceMapObj *)(argp1);
   20788           0 :   result = (int) ((arg1)->height);
   20789             :   resultobj = SWIG_From_int((int)(result));
   20790           0 :   return resultobj;
   20791           0 : fail:
   20792             :   return NULL;
   20793             : }
   20794             : 
   20795             : 
   20796           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20797             :   PyObject *resultobj = 0;
   20798             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20799             :   int arg2 ;
   20800           0 :   void *argp1 = 0 ;
   20801             :   int res1 = 0 ;
   20802             :   int val2 ;
   20803             :   int ecode2 = 0 ;
   20804           0 :   PyObject * obj0 = 0 ;
   20805           0 :   PyObject * obj1 = 0 ;
   20806             :   
   20807           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_width_set",&obj0,&obj1)) SWIG_fail;
   20808           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20809           0 :   if (!SWIG_IsOK(res1)) {
   20810           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_width_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20811             :   }
   20812           0 :   arg1 = (referenceMapObj *)(argp1);
   20813           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   20814           0 :   if (!SWIG_IsOK(ecode2)) {
   20815           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_width_set" "', argument " "2"" of type '" "int""'");
   20816             :   } 
   20817             :   arg2 = (int)(val2);
   20818           0 :   if (arg1) (arg1)->width = arg2;
   20819             :   resultobj = SWIG_Py_Void();
   20820           0 :   return resultobj;
   20821           0 : fail:
   20822             :   return NULL;
   20823             : }
   20824             : 
   20825             : 
   20826           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20827             :   PyObject *resultobj = 0;
   20828             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20829           0 :   void *argp1 = 0 ;
   20830             :   int res1 = 0 ;
   20831           0 :   PyObject * obj0 = 0 ;
   20832             :   int result;
   20833             :   
   20834           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_width_get",&obj0)) SWIG_fail;
   20835           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20836           0 :   if (!SWIG_IsOK(res1)) {
   20837           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_width_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20838             :   }
   20839           0 :   arg1 = (referenceMapObj *)(argp1);
   20840           0 :   result = (int) ((arg1)->width);
   20841             :   resultobj = SWIG_From_int((int)(result));
   20842           0 :   return resultobj;
   20843           0 : fail:
   20844             :   return NULL;
   20845             : }
   20846             : 
   20847             : 
   20848           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20849             :   PyObject *resultobj = 0;
   20850             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20851             :   colorObj *arg2 = (colorObj *) 0 ;
   20852           0 :   void *argp1 = 0 ;
   20853             :   int res1 = 0 ;
   20854           0 :   void *argp2 = 0 ;
   20855             :   int res2 = 0 ;
   20856           0 :   PyObject * obj0 = 0 ;
   20857           0 :   PyObject * obj1 = 0 ;
   20858             :   
   20859           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_color_set",&obj0,&obj1)) SWIG_fail;
   20860           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20861           0 :   if (!SWIG_IsOK(res1)) {
   20862           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_color_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20863             :   }
   20864           0 :   arg1 = (referenceMapObj *)(argp1);
   20865           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   20866           0 :   if (!SWIG_IsOK(res2)) {
   20867           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_color_set" "', argument " "2"" of type '" "colorObj *""'"); 
   20868             :   }
   20869           0 :   arg2 = (colorObj *)(argp2);
   20870           0 :   if (arg1) (arg1)->color = *arg2;
   20871             :   resultobj = SWIG_Py_Void();
   20872           0 :   return resultobj;
   20873           0 : fail:
   20874             :   return NULL;
   20875             : }
   20876             : 
   20877             : 
   20878           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20879             :   PyObject *resultobj = 0;
   20880             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20881           0 :   void *argp1 = 0 ;
   20882             :   int res1 = 0 ;
   20883           0 :   PyObject * obj0 = 0 ;
   20884             :   colorObj *result = 0 ;
   20885             :   
   20886           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_color_get",&obj0)) SWIG_fail;
   20887           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20888           0 :   if (!SWIG_IsOK(res1)) {
   20889           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_color_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20890             :   }
   20891           0 :   arg1 = (referenceMapObj *)(argp1);
   20892           0 :   result = (colorObj *)& ((arg1)->color);
   20893           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   20894           0 :   return resultobj;
   20895           0 : fail:
   20896             :   return NULL;
   20897             : }
   20898             : 
   20899             : 
   20900           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20901             :   PyObject *resultobj = 0;
   20902             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20903             :   colorObj *arg2 = (colorObj *) 0 ;
   20904           0 :   void *argp1 = 0 ;
   20905             :   int res1 = 0 ;
   20906           0 :   void *argp2 = 0 ;
   20907             :   int res2 = 0 ;
   20908           0 :   PyObject * obj0 = 0 ;
   20909           0 :   PyObject * obj1 = 0 ;
   20910             :   
   20911           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
   20912           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20913           0 :   if (!SWIG_IsOK(res1)) {
   20914           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_outlinecolor_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20915             :   }
   20916           0 :   arg1 = (referenceMapObj *)(argp1);
   20917           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   20918           0 :   if (!SWIG_IsOK(res2)) {
   20919           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   20920             :   }
   20921           0 :   arg2 = (colorObj *)(argp2);
   20922           0 :   if (arg1) (arg1)->outlinecolor = *arg2;
   20923             :   resultobj = SWIG_Py_Void();
   20924           0 :   return resultobj;
   20925           0 : fail:
   20926             :   return NULL;
   20927             : }
   20928             : 
   20929             : 
   20930           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20931             :   PyObject *resultobj = 0;
   20932             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20933           0 :   void *argp1 = 0 ;
   20934             :   int res1 = 0 ;
   20935           0 :   PyObject * obj0 = 0 ;
   20936             :   colorObj *result = 0 ;
   20937             :   
   20938           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_outlinecolor_get",&obj0)) SWIG_fail;
   20939           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20940           0 :   if (!SWIG_IsOK(res1)) {
   20941           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_outlinecolor_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20942             :   }
   20943           0 :   arg1 = (referenceMapObj *)(argp1);
   20944           0 :   result = (colorObj *)& ((arg1)->outlinecolor);
   20945           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   20946           0 :   return resultobj;
   20947           0 : fail:
   20948             :   return NULL;
   20949             : }
   20950             : 
   20951             : 
   20952           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_image_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20953             :   PyObject *resultobj = 0;
   20954             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20955             :   char *arg2 = (char *) 0 ;
   20956           0 :   void *argp1 = 0 ;
   20957             :   int res1 = 0 ;
   20958             :   int res2 ;
   20959           0 :   char *buf2 = 0 ;
   20960           0 :   int alloc2 = 0 ;
   20961           0 :   PyObject * obj0 = 0 ;
   20962           0 :   PyObject * obj1 = 0 ;
   20963             :   
   20964           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_image_set",&obj0,&obj1)) SWIG_fail;
   20965           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   20966           0 :   if (!SWIG_IsOK(res1)) {
   20967           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_image_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   20968             :   }
   20969           0 :   arg1 = (referenceMapObj *)(argp1);
   20970           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   20971           0 :   if (!SWIG_IsOK(res2)) {
   20972           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_image_set" "', argument " "2"" of type '" "char *""'");
   20973             :   }
   20974           0 :   arg2 = (char *)(buf2);
   20975             :   {
   20976           0 :     if (arg1->image) free((char*)arg1->image);
   20977           0 :     if (arg2) {
   20978           0 :       arg1->image = (char *) malloc(strlen(arg2)+1);
   20979             :       strcpy((char*)arg1->image,arg2);
   20980             :     } else {
   20981           0 :       arg1->image = 0;
   20982             :     }
   20983             :   }
   20984             :   resultobj = SWIG_Py_Void();
   20985           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20986             :   return resultobj;
   20987           0 : fail:
   20988           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   20989             :   return NULL;
   20990             : }
   20991             : 
   20992             : 
   20993           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_image_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   20994             :   PyObject *resultobj = 0;
   20995             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   20996           0 :   void *argp1 = 0 ;
   20997             :   int res1 = 0 ;
   20998           0 :   PyObject * obj0 = 0 ;
   20999             :   char *result = 0 ;
   21000             :   
   21001           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_image_get",&obj0)) SWIG_fail;
   21002           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21003           0 :   if (!SWIG_IsOK(res1)) {
   21004           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_image_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21005             :   }
   21006           0 :   arg1 = (referenceMapObj *)(argp1);
   21007           0 :   result = (char *) ((arg1)->image);
   21008           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   21009           0 :   return resultobj;
   21010           0 : fail:
   21011             :   return NULL;
   21012             : }
   21013             : 
   21014             : 
   21015           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21016             :   PyObject *resultobj = 0;
   21017             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21018             :   int arg2 ;
   21019           0 :   void *argp1 = 0 ;
   21020             :   int res1 = 0 ;
   21021             :   int val2 ;
   21022             :   int ecode2 = 0 ;
   21023           0 :   PyObject * obj0 = 0 ;
   21024           0 :   PyObject * obj1 = 0 ;
   21025             :   
   21026           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_status_set",&obj0,&obj1)) SWIG_fail;
   21027           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21028           0 :   if (!SWIG_IsOK(res1)) {
   21029           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_status_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21030             :   }
   21031           0 :   arg1 = (referenceMapObj *)(argp1);
   21032           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21033           0 :   if (!SWIG_IsOK(ecode2)) {
   21034           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_status_set" "', argument " "2"" of type '" "int""'");
   21035             :   } 
   21036             :   arg2 = (int)(val2);
   21037           0 :   if (arg1) (arg1)->status = arg2;
   21038             :   resultobj = SWIG_Py_Void();
   21039           0 :   return resultobj;
   21040           0 : fail:
   21041             :   return NULL;
   21042             : }
   21043             : 
   21044             : 
   21045           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21046             :   PyObject *resultobj = 0;
   21047             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21048           0 :   void *argp1 = 0 ;
   21049             :   int res1 = 0 ;
   21050           0 :   PyObject * obj0 = 0 ;
   21051             :   int result;
   21052             :   
   21053           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_status_get",&obj0)) SWIG_fail;
   21054           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21055           0 :   if (!SWIG_IsOK(res1)) {
   21056           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_status_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21057             :   }
   21058           0 :   arg1 = (referenceMapObj *)(argp1);
   21059           0 :   result = (int) ((arg1)->status);
   21060             :   resultobj = SWIG_From_int((int)(result));
   21061           0 :   return resultobj;
   21062           0 : fail:
   21063             :   return NULL;
   21064             : }
   21065             : 
   21066             : 
   21067           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_marker_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21068             :   PyObject *resultobj = 0;
   21069             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21070             :   int arg2 ;
   21071           0 :   void *argp1 = 0 ;
   21072             :   int res1 = 0 ;
   21073             :   int val2 ;
   21074             :   int ecode2 = 0 ;
   21075           0 :   PyObject * obj0 = 0 ;
   21076           0 :   PyObject * obj1 = 0 ;
   21077             :   
   21078           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_marker_set",&obj0,&obj1)) SWIG_fail;
   21079           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21080           0 :   if (!SWIG_IsOK(res1)) {
   21081           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_marker_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21082             :   }
   21083           0 :   arg1 = (referenceMapObj *)(argp1);
   21084           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21085           0 :   if (!SWIG_IsOK(ecode2)) {
   21086           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_marker_set" "', argument " "2"" of type '" "int""'");
   21087             :   } 
   21088             :   arg2 = (int)(val2);
   21089           0 :   if (arg1) (arg1)->marker = arg2;
   21090             :   resultobj = SWIG_Py_Void();
   21091           0 :   return resultobj;
   21092           0 : fail:
   21093             :   return NULL;
   21094             : }
   21095             : 
   21096             : 
   21097           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_marker_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21098             :   PyObject *resultobj = 0;
   21099             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21100           0 :   void *argp1 = 0 ;
   21101             :   int res1 = 0 ;
   21102           0 :   PyObject * obj0 = 0 ;
   21103             :   int result;
   21104             :   
   21105           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_marker_get",&obj0)) SWIG_fail;
   21106           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21107           0 :   if (!SWIG_IsOK(res1)) {
   21108           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_marker_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21109             :   }
   21110           0 :   arg1 = (referenceMapObj *)(argp1);
   21111           0 :   result = (int) ((arg1)->marker);
   21112             :   resultobj = SWIG_From_int((int)(result));
   21113           0 :   return resultobj;
   21114           0 : fail:
   21115             :   return NULL;
   21116             : }
   21117             : 
   21118             : 
   21119           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markername_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21120             :   PyObject *resultobj = 0;
   21121             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21122             :   char *arg2 = (char *) 0 ;
   21123           0 :   void *argp1 = 0 ;
   21124             :   int res1 = 0 ;
   21125             :   int res2 ;
   21126           0 :   char *buf2 = 0 ;
   21127           0 :   int alloc2 = 0 ;
   21128           0 :   PyObject * obj0 = 0 ;
   21129           0 :   PyObject * obj1 = 0 ;
   21130             :   
   21131           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_markername_set",&obj0,&obj1)) SWIG_fail;
   21132           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21133           0 :   if (!SWIG_IsOK(res1)) {
   21134           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markername_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21135             :   }
   21136           0 :   arg1 = (referenceMapObj *)(argp1);
   21137           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   21138           0 :   if (!SWIG_IsOK(res2)) {
   21139           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_markername_set" "', argument " "2"" of type '" "char *""'");
   21140             :   }
   21141           0 :   arg2 = (char *)(buf2);
   21142             :   {
   21143           0 :     if (arg1->markername) free((char*)arg1->markername);
   21144           0 :     if (arg2) {
   21145           0 :       arg1->markername = (char *) malloc(strlen(arg2)+1);
   21146             :       strcpy((char*)arg1->markername,arg2);
   21147             :     } else {
   21148           0 :       arg1->markername = 0;
   21149             :     }
   21150             :   }
   21151             :   resultobj = SWIG_Py_Void();
   21152           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   21153             :   return resultobj;
   21154           0 : fail:
   21155           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   21156             :   return NULL;
   21157             : }
   21158             : 
   21159             : 
   21160           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markername_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21161             :   PyObject *resultobj = 0;
   21162             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21163           0 :   void *argp1 = 0 ;
   21164             :   int res1 = 0 ;
   21165           0 :   PyObject * obj0 = 0 ;
   21166             :   char *result = 0 ;
   21167             :   
   21168           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_markername_get",&obj0)) SWIG_fail;
   21169           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21170           0 :   if (!SWIG_IsOK(res1)) {
   21171           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markername_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21172             :   }
   21173           0 :   arg1 = (referenceMapObj *)(argp1);
   21174           0 :   result = (char *) ((arg1)->markername);
   21175           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   21176           0 :   return resultobj;
   21177           0 : fail:
   21178             :   return NULL;
   21179             : }
   21180             : 
   21181             : 
   21182           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markersize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21183             :   PyObject *resultobj = 0;
   21184             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21185             :   int arg2 ;
   21186           0 :   void *argp1 = 0 ;
   21187             :   int res1 = 0 ;
   21188             :   int val2 ;
   21189             :   int ecode2 = 0 ;
   21190           0 :   PyObject * obj0 = 0 ;
   21191           0 :   PyObject * obj1 = 0 ;
   21192             :   
   21193           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_markersize_set",&obj0,&obj1)) SWIG_fail;
   21194           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21195           0 :   if (!SWIG_IsOK(res1)) {
   21196           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markersize_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21197             :   }
   21198           0 :   arg1 = (referenceMapObj *)(argp1);
   21199           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21200           0 :   if (!SWIG_IsOK(ecode2)) {
   21201           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_markersize_set" "', argument " "2"" of type '" "int""'");
   21202             :   } 
   21203             :   arg2 = (int)(val2);
   21204           0 :   if (arg1) (arg1)->markersize = arg2;
   21205             :   resultobj = SWIG_Py_Void();
   21206           0 :   return resultobj;
   21207           0 : fail:
   21208             :   return NULL;
   21209             : }
   21210             : 
   21211             : 
   21212           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markersize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21213             :   PyObject *resultobj = 0;
   21214             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21215           0 :   void *argp1 = 0 ;
   21216             :   int res1 = 0 ;
   21217           0 :   PyObject * obj0 = 0 ;
   21218             :   int result;
   21219             :   
   21220           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_markersize_get",&obj0)) SWIG_fail;
   21221           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21222           0 :   if (!SWIG_IsOK(res1)) {
   21223           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markersize_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21224             :   }
   21225           0 :   arg1 = (referenceMapObj *)(argp1);
   21226           0 :   result = (int) ((arg1)->markersize);
   21227             :   resultobj = SWIG_From_int((int)(result));
   21228           0 :   return resultobj;
   21229           0 : fail:
   21230             :   return NULL;
   21231             : }
   21232             : 
   21233             : 
   21234           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_minboxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21235             :   PyObject *resultobj = 0;
   21236             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21237             :   int arg2 ;
   21238           0 :   void *argp1 = 0 ;
   21239             :   int res1 = 0 ;
   21240             :   int val2 ;
   21241             :   int ecode2 = 0 ;
   21242           0 :   PyObject * obj0 = 0 ;
   21243           0 :   PyObject * obj1 = 0 ;
   21244             :   
   21245           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_minboxsize_set",&obj0,&obj1)) SWIG_fail;
   21246           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21247           0 :   if (!SWIG_IsOK(res1)) {
   21248           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_minboxsize_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21249             :   }
   21250           0 :   arg1 = (referenceMapObj *)(argp1);
   21251           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21252           0 :   if (!SWIG_IsOK(ecode2)) {
   21253           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_minboxsize_set" "', argument " "2"" of type '" "int""'");
   21254             :   } 
   21255             :   arg2 = (int)(val2);
   21256           0 :   if (arg1) (arg1)->minboxsize = arg2;
   21257             :   resultobj = SWIG_Py_Void();
   21258           0 :   return resultobj;
   21259           0 : fail:
   21260             :   return NULL;
   21261             : }
   21262             : 
   21263             : 
   21264           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_minboxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21265             :   PyObject *resultobj = 0;
   21266             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21267           0 :   void *argp1 = 0 ;
   21268             :   int res1 = 0 ;
   21269           0 :   PyObject * obj0 = 0 ;
   21270             :   int result;
   21271             :   
   21272           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_minboxsize_get",&obj0)) SWIG_fail;
   21273           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21274           0 :   if (!SWIG_IsOK(res1)) {
   21275           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_minboxsize_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21276             :   }
   21277           0 :   arg1 = (referenceMapObj *)(argp1);
   21278           0 :   result = (int) ((arg1)->minboxsize);
   21279             :   resultobj = SWIG_From_int((int)(result));
   21280           0 :   return resultobj;
   21281           0 : fail:
   21282             :   return NULL;
   21283             : }
   21284             : 
   21285             : 
   21286           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_maxboxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21287             :   PyObject *resultobj = 0;
   21288             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21289             :   int arg2 ;
   21290           0 :   void *argp1 = 0 ;
   21291             :   int res1 = 0 ;
   21292             :   int val2 ;
   21293             :   int ecode2 = 0 ;
   21294           0 :   PyObject * obj0 = 0 ;
   21295           0 :   PyObject * obj1 = 0 ;
   21296             :   
   21297           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_maxboxsize_set",&obj0,&obj1)) SWIG_fail;
   21298           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21299           0 :   if (!SWIG_IsOK(res1)) {
   21300           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_maxboxsize_set" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21301             :   }
   21302           0 :   arg1 = (referenceMapObj *)(argp1);
   21303           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21304           0 :   if (!SWIG_IsOK(ecode2)) {
   21305           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_maxboxsize_set" "', argument " "2"" of type '" "int""'");
   21306             :   } 
   21307             :   arg2 = (int)(val2);
   21308           0 :   if (arg1) (arg1)->maxboxsize = arg2;
   21309             :   resultobj = SWIG_Py_Void();
   21310           0 :   return resultobj;
   21311           0 : fail:
   21312             :   return NULL;
   21313             : }
   21314             : 
   21315             : 
   21316           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_maxboxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21317             :   PyObject *resultobj = 0;
   21318             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21319           0 :   void *argp1 = 0 ;
   21320             :   int res1 = 0 ;
   21321           0 :   PyObject * obj0 = 0 ;
   21322             :   int result;
   21323             :   
   21324           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_maxboxsize_get",&obj0)) SWIG_fail;
   21325           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21326           0 :   if (!SWIG_IsOK(res1)) {
   21327           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_maxboxsize_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21328             :   }
   21329           0 :   arg1 = (referenceMapObj *)(argp1);
   21330           0 :   result = (int) ((arg1)->maxboxsize);
   21331             :   resultobj = SWIG_From_int((int)(result));
   21332           0 :   return resultobj;
   21333           0 : fail:
   21334             :   return NULL;
   21335             : }
   21336             : 
   21337             : 
   21338           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21339             :   PyObject *resultobj = 0;
   21340             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21341           0 :   void *argp1 = 0 ;
   21342             :   int res1 = 0 ;
   21343           0 :   PyObject * obj0 = 0 ;
   21344             :   struct mapObj *result = 0 ;
   21345             :   
   21346           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_map_get",&obj0)) SWIG_fail;
   21347           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21348           0 :   if (!SWIG_IsOK(res1)) {
   21349           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_map_get" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21350             :   }
   21351           0 :   arg1 = (referenceMapObj *)(argp1);
   21352           0 :   result = (struct mapObj *) ((arg1)->map);
   21353           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 |  0 );
   21354           0 :   return resultobj;
   21355           0 : fail:
   21356             :   return NULL;
   21357             : }
   21358             : 
   21359             : 
   21360           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21361             :   PyObject *resultobj = 0;
   21362             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21363             :   char *arg2 = (char *) 0 ;
   21364           0 :   void *argp1 = 0 ;
   21365             :   int res1 = 0 ;
   21366             :   int res2 ;
   21367           0 :   char *buf2 = 0 ;
   21368           0 :   int alloc2 = 0 ;
   21369           0 :   PyObject * obj0 = 0 ;
   21370           0 :   PyObject * obj1 = 0 ;
   21371             :   int result;
   21372             :   
   21373           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   21374           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21375           0 :   if (!SWIG_IsOK(res1)) {
   21376           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_updateFromString" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21377             :   }
   21378           0 :   arg1 = (referenceMapObj *)(argp1);
   21379           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   21380           0 :   if (!SWIG_IsOK(res2)) {
   21381           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   21382             :   }
   21383           0 :   arg2 = (char *)(buf2);
   21384             :   {
   21385             :     result = (int)referenceMapObj_updateFromString(arg1,arg2); {
   21386           0 :       errorObj *ms_error = msGetErrorObj();
   21387             :       
   21388           0 :       switch(ms_error->code) {
   21389             :       case MS_NOERR:
   21390             :         break;
   21391           0 :       case MS_NOTFOUND:
   21392           0 :         msResetErrorList();
   21393           0 :         break;
   21394             :       case -1:
   21395             :         break;
   21396           0 :       case MS_IOERR:
   21397           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   21398           0 :           _raise_ms_exception();
   21399           0 :           msResetErrorList();
   21400           0 :           return NULL;
   21401             :         }
   21402             :       default:
   21403           0 :         _raise_ms_exception();
   21404           0 :         msResetErrorList();
   21405           0 :         return NULL;
   21406             :       }
   21407             :       
   21408             :     }
   21409             :   }
   21410             :   resultobj = SWIG_From_int((int)(result));
   21411           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   21412             :   return resultobj;
   21413           0 : fail:
   21414           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   21415             :   return NULL;
   21416             : }
   21417             : 
   21418             : 
   21419           0 : SWIGINTERN PyObject *_wrap_referenceMapObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21420             :   PyObject *resultobj = 0;
   21421             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21422           0 :   void *argp1 = 0 ;
   21423             :   int res1 = 0 ;
   21424           0 :   PyObject * obj0 = 0 ;
   21425             :   char *result = 0 ;
   21426             :   
   21427           0 :   if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_convertToString",&obj0)) SWIG_fail;
   21428           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 |  0 );
   21429           0 :   if (!SWIG_IsOK(res1)) {
   21430           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_convertToString" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21431             :   }
   21432           0 :   arg1 = (referenceMapObj *)(argp1);
   21433             :   {
   21434             :     result = (char *)referenceMapObj_convertToString(arg1); {
   21435           0 :       errorObj *ms_error = msGetErrorObj();
   21436             :       
   21437           0 :       switch(ms_error->code) {
   21438             :       case MS_NOERR:
   21439             :         break;
   21440           0 :       case MS_NOTFOUND:
   21441           0 :         msResetErrorList();
   21442           0 :         break;
   21443             :       case -1:
   21444             :         break;
   21445           0 :       case MS_IOERR:
   21446           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   21447           0 :           _raise_ms_exception();
   21448           0 :           msResetErrorList();
   21449           0 :           return NULL;
   21450             :         }
   21451             :       default:
   21452           0 :         _raise_ms_exception();
   21453           0 :         msResetErrorList();
   21454           0 :         return NULL;
   21455             :       }
   21456             :       
   21457             :     }
   21458             :   }
   21459           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   21460           0 :   free((char*)result);
   21461           0 :   return resultobj;
   21462           0 : fail:
   21463             :   return NULL;
   21464             : }
   21465             : 
   21466             : 
   21467           0 : SWIGINTERN PyObject *_wrap_new_referenceMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21468             :   PyObject *resultobj = 0;
   21469             :   referenceMapObj *result = 0 ;
   21470             :   
   21471           0 :   if (!PyArg_ParseTuple(args,(char *)":new_referenceMapObj")) SWIG_fail;
   21472             :   {
   21473           0 :     result = (referenceMapObj *)calloc(1, sizeof(referenceMapObj)); {
   21474           0 :       errorObj *ms_error = msGetErrorObj();
   21475             :       
   21476           0 :       switch(ms_error->code) {
   21477             :       case MS_NOERR:
   21478             :         break;
   21479           0 :       case MS_NOTFOUND:
   21480           0 :         msResetErrorList();
   21481           0 :         break;
   21482             :       case -1:
   21483             :         break;
   21484           0 :       case MS_IOERR:
   21485           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   21486           0 :           _raise_ms_exception();
   21487           0 :           msResetErrorList();
   21488           0 :           return NULL;
   21489             :         }
   21490             :       default:
   21491           0 :         _raise_ms_exception();
   21492           0 :         msResetErrorList();
   21493           0 :         return NULL;
   21494             :       }
   21495             :       
   21496             :     }
   21497             :   }
   21498           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_referenceMapObj, SWIG_POINTER_NEW |  0 );
   21499           0 :   return resultobj;
   21500           0 : fail:
   21501             :   return NULL;
   21502             : }
   21503             : 
   21504             : 
   21505           0 : SWIGINTERN PyObject *_wrap_delete_referenceMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21506             :   PyObject *resultobj = 0;
   21507             :   referenceMapObj *arg1 = (referenceMapObj *) 0 ;
   21508           0 :   void *argp1 = 0 ;
   21509             :   int res1 = 0 ;
   21510           0 :   PyObject * obj0 = 0 ;
   21511             :   
   21512           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_referenceMapObj",&obj0)) SWIG_fail;
   21513           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, SWIG_POINTER_DISOWN |  0 );
   21514           0 :   if (!SWIG_IsOK(res1)) {
   21515           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_referenceMapObj" "', argument " "1"" of type '" "referenceMapObj *""'"); 
   21516             :   }
   21517           0 :   arg1 = (referenceMapObj *)(argp1);
   21518             :   {
   21519           0 :     free((char *) arg1); {
   21520           0 :       errorObj *ms_error = msGetErrorObj();
   21521             :       
   21522           0 :       switch(ms_error->code) {
   21523             :       case MS_NOERR:
   21524             :         break;
   21525           0 :       case MS_NOTFOUND:
   21526           0 :         msResetErrorList();
   21527           0 :         break;
   21528             :       case -1:
   21529             :         break;
   21530           0 :       case MS_IOERR:
   21531           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   21532           0 :           _raise_ms_exception();
   21533           0 :           msResetErrorList();
   21534           0 :           return NULL;
   21535             :         }
   21536             :       default:
   21537           0 :         _raise_ms_exception();
   21538           0 :         msResetErrorList();
   21539           0 :         return NULL;
   21540             :       }
   21541             :       
   21542             :     }
   21543             :   }
   21544             :   resultobj = SWIG_Py_Void();
   21545           0 :   return resultobj;
   21546           0 : fail:
   21547             :   return NULL;
   21548             : }
   21549             : 
   21550             : 
   21551           1 : SWIGINTERN PyObject *referenceMapObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21552             :   PyObject *obj;
   21553           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   21554           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_referenceMapObj, SWIG_NewClientData(obj));
   21555           1 :   return SWIG_Py_Void();
   21556             : }
   21557             : 
   21558           0 : SWIGINTERN PyObject *_wrap_scalebarObj_imagecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21559             :   PyObject *resultobj = 0;
   21560             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21561             :   colorObj *arg2 = (colorObj *) 0 ;
   21562           0 :   void *argp1 = 0 ;
   21563             :   int res1 = 0 ;
   21564           0 :   void *argp2 = 0 ;
   21565             :   int res2 = 0 ;
   21566           0 :   PyObject * obj0 = 0 ;
   21567           0 :   PyObject * obj1 = 0 ;
   21568             :   
   21569           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_imagecolor_set",&obj0,&obj1)) SWIG_fail;
   21570           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21571           0 :   if (!SWIG_IsOK(res1)) {
   21572           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_imagecolor_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21573             :   }
   21574           0 :   arg1 = (scalebarObj *)(argp1);
   21575           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   21576           0 :   if (!SWIG_IsOK(res2)) {
   21577           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_imagecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   21578             :   }
   21579           0 :   arg2 = (colorObj *)(argp2);
   21580           0 :   if (arg1) (arg1)->imagecolor = *arg2;
   21581             :   resultobj = SWIG_Py_Void();
   21582           0 :   return resultobj;
   21583           0 : fail:
   21584             :   return NULL;
   21585             : }
   21586             : 
   21587             : 
   21588           0 : SWIGINTERN PyObject *_wrap_scalebarObj_imagecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21589             :   PyObject *resultobj = 0;
   21590             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21591           0 :   void *argp1 = 0 ;
   21592             :   int res1 = 0 ;
   21593           0 :   PyObject * obj0 = 0 ;
   21594             :   colorObj *result = 0 ;
   21595             :   
   21596           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_imagecolor_get",&obj0)) SWIG_fail;
   21597           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21598           0 :   if (!SWIG_IsOK(res1)) {
   21599           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_imagecolor_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21600             :   }
   21601           0 :   arg1 = (scalebarObj *)(argp1);
   21602           0 :   result = (colorObj *)& ((arg1)->imagecolor);
   21603           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   21604           0 :   return resultobj;
   21605           0 : fail:
   21606             :   return NULL;
   21607             : }
   21608             : 
   21609             : 
   21610           0 : SWIGINTERN PyObject *_wrap_scalebarObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21611             :   PyObject *resultobj = 0;
   21612             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21613             :   int arg2 ;
   21614           0 :   void *argp1 = 0 ;
   21615             :   int res1 = 0 ;
   21616             :   int val2 ;
   21617             :   int ecode2 = 0 ;
   21618           0 :   PyObject * obj0 = 0 ;
   21619           0 :   PyObject * obj1 = 0 ;
   21620             :   
   21621           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_height_set",&obj0,&obj1)) SWIG_fail;
   21622           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21623           0 :   if (!SWIG_IsOK(res1)) {
   21624           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_height_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21625             :   }
   21626           0 :   arg1 = (scalebarObj *)(argp1);
   21627           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21628           0 :   if (!SWIG_IsOK(ecode2)) {
   21629           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_height_set" "', argument " "2"" of type '" "int""'");
   21630             :   } 
   21631             :   arg2 = (int)(val2);
   21632           0 :   if (arg1) (arg1)->height = arg2;
   21633             :   resultobj = SWIG_Py_Void();
   21634           0 :   return resultobj;
   21635           0 : fail:
   21636             :   return NULL;
   21637             : }
   21638             : 
   21639             : 
   21640           0 : SWIGINTERN PyObject *_wrap_scalebarObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21641             :   PyObject *resultobj = 0;
   21642             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21643           0 :   void *argp1 = 0 ;
   21644             :   int res1 = 0 ;
   21645           0 :   PyObject * obj0 = 0 ;
   21646             :   int result;
   21647             :   
   21648           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_height_get",&obj0)) SWIG_fail;
   21649           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21650           0 :   if (!SWIG_IsOK(res1)) {
   21651           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_height_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21652             :   }
   21653           0 :   arg1 = (scalebarObj *)(argp1);
   21654           0 :   result = (int) ((arg1)->height);
   21655             :   resultobj = SWIG_From_int((int)(result));
   21656           0 :   return resultobj;
   21657           0 : fail:
   21658             :   return NULL;
   21659             : }
   21660             : 
   21661             : 
   21662           0 : SWIGINTERN PyObject *_wrap_scalebarObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21663             :   PyObject *resultobj = 0;
   21664             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21665             :   int arg2 ;
   21666           0 :   void *argp1 = 0 ;
   21667             :   int res1 = 0 ;
   21668             :   int val2 ;
   21669             :   int ecode2 = 0 ;
   21670           0 :   PyObject * obj0 = 0 ;
   21671           0 :   PyObject * obj1 = 0 ;
   21672             :   
   21673           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_width_set",&obj0,&obj1)) SWIG_fail;
   21674           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21675           0 :   if (!SWIG_IsOK(res1)) {
   21676           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_width_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21677             :   }
   21678           0 :   arg1 = (scalebarObj *)(argp1);
   21679           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21680           0 :   if (!SWIG_IsOK(ecode2)) {
   21681           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_width_set" "', argument " "2"" of type '" "int""'");
   21682             :   } 
   21683             :   arg2 = (int)(val2);
   21684           0 :   if (arg1) (arg1)->width = arg2;
   21685             :   resultobj = SWIG_Py_Void();
   21686           0 :   return resultobj;
   21687           0 : fail:
   21688             :   return NULL;
   21689             : }
   21690             : 
   21691             : 
   21692           0 : SWIGINTERN PyObject *_wrap_scalebarObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21693             :   PyObject *resultobj = 0;
   21694             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21695           0 :   void *argp1 = 0 ;
   21696             :   int res1 = 0 ;
   21697           0 :   PyObject * obj0 = 0 ;
   21698             :   int result;
   21699             :   
   21700           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_width_get",&obj0)) SWIG_fail;
   21701           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21702           0 :   if (!SWIG_IsOK(res1)) {
   21703           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_width_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21704             :   }
   21705           0 :   arg1 = (scalebarObj *)(argp1);
   21706           0 :   result = (int) ((arg1)->width);
   21707             :   resultobj = SWIG_From_int((int)(result));
   21708           0 :   return resultobj;
   21709           0 : fail:
   21710             :   return NULL;
   21711             : }
   21712             : 
   21713             : 
   21714           0 : SWIGINTERN PyObject *_wrap_scalebarObj_style_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21715             :   PyObject *resultobj = 0;
   21716             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21717             :   int arg2 ;
   21718           0 :   void *argp1 = 0 ;
   21719             :   int res1 = 0 ;
   21720             :   int val2 ;
   21721             :   int ecode2 = 0 ;
   21722           0 :   PyObject * obj0 = 0 ;
   21723           0 :   PyObject * obj1 = 0 ;
   21724             :   
   21725           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_style_set",&obj0,&obj1)) SWIG_fail;
   21726           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21727           0 :   if (!SWIG_IsOK(res1)) {
   21728           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_style_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21729             :   }
   21730           0 :   arg1 = (scalebarObj *)(argp1);
   21731           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21732           0 :   if (!SWIG_IsOK(ecode2)) {
   21733           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_style_set" "', argument " "2"" of type '" "int""'");
   21734             :   } 
   21735             :   arg2 = (int)(val2);
   21736           0 :   if (arg1) (arg1)->style = arg2;
   21737             :   resultobj = SWIG_Py_Void();
   21738           0 :   return resultobj;
   21739           0 : fail:
   21740             :   return NULL;
   21741             : }
   21742             : 
   21743             : 
   21744           0 : SWIGINTERN PyObject *_wrap_scalebarObj_style_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21745             :   PyObject *resultobj = 0;
   21746             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21747           0 :   void *argp1 = 0 ;
   21748             :   int res1 = 0 ;
   21749           0 :   PyObject * obj0 = 0 ;
   21750             :   int result;
   21751             :   
   21752           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_style_get",&obj0)) SWIG_fail;
   21753           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21754           0 :   if (!SWIG_IsOK(res1)) {
   21755           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_style_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21756             :   }
   21757           0 :   arg1 = (scalebarObj *)(argp1);
   21758           0 :   result = (int) ((arg1)->style);
   21759             :   resultobj = SWIG_From_int((int)(result));
   21760           0 :   return resultobj;
   21761           0 : fail:
   21762             :   return NULL;
   21763             : }
   21764             : 
   21765             : 
   21766           0 : SWIGINTERN PyObject *_wrap_scalebarObj_intervals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21767             :   PyObject *resultobj = 0;
   21768             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21769             :   int arg2 ;
   21770           0 :   void *argp1 = 0 ;
   21771             :   int res1 = 0 ;
   21772             :   int val2 ;
   21773             :   int ecode2 = 0 ;
   21774           0 :   PyObject * obj0 = 0 ;
   21775           0 :   PyObject * obj1 = 0 ;
   21776             :   
   21777           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_intervals_set",&obj0,&obj1)) SWIG_fail;
   21778           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21779           0 :   if (!SWIG_IsOK(res1)) {
   21780           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_intervals_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21781             :   }
   21782           0 :   arg1 = (scalebarObj *)(argp1);
   21783           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   21784           0 :   if (!SWIG_IsOK(ecode2)) {
   21785           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_intervals_set" "', argument " "2"" of type '" "int""'");
   21786             :   } 
   21787             :   arg2 = (int)(val2);
   21788           0 :   if (arg1) (arg1)->intervals = arg2;
   21789             :   resultobj = SWIG_Py_Void();
   21790           0 :   return resultobj;
   21791           0 : fail:
   21792             :   return NULL;
   21793             : }
   21794             : 
   21795             : 
   21796           0 : SWIGINTERN PyObject *_wrap_scalebarObj_intervals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21797             :   PyObject *resultobj = 0;
   21798             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21799           0 :   void *argp1 = 0 ;
   21800             :   int res1 = 0 ;
   21801           0 :   PyObject * obj0 = 0 ;
   21802             :   int result;
   21803             :   
   21804           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_intervals_get",&obj0)) SWIG_fail;
   21805           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21806           0 :   if (!SWIG_IsOK(res1)) {
   21807           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_intervals_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21808             :   }
   21809           0 :   arg1 = (scalebarObj *)(argp1);
   21810           0 :   result = (int) ((arg1)->intervals);
   21811             :   resultobj = SWIG_From_int((int)(result));
   21812           0 :   return resultobj;
   21813           0 : fail:
   21814             :   return NULL;
   21815             : }
   21816             : 
   21817             : 
   21818           0 : SWIGINTERN PyObject *_wrap_scalebarObj_label_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21819             :   PyObject *resultobj = 0;
   21820             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21821             :   labelObj *arg2 = (labelObj *) 0 ;
   21822           0 :   void *argp1 = 0 ;
   21823             :   int res1 = 0 ;
   21824           0 :   void *argp2 = 0 ;
   21825             :   int res2 = 0 ;
   21826           0 :   PyObject * obj0 = 0 ;
   21827           0 :   PyObject * obj1 = 0 ;
   21828             :   
   21829           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_label_set",&obj0,&obj1)) SWIG_fail;
   21830           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21831           0 :   if (!SWIG_IsOK(res1)) {
   21832           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_label_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21833             :   }
   21834           0 :   arg1 = (scalebarObj *)(argp1);
   21835           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_labelObj, 0 |  0 );
   21836           0 :   if (!SWIG_IsOK(res2)) {
   21837           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_label_set" "', argument " "2"" of type '" "labelObj *""'"); 
   21838             :   }
   21839           0 :   arg2 = (labelObj *)(argp2);
   21840           0 :   if (arg1) (arg1)->label = *arg2;
   21841             :   resultobj = SWIG_Py_Void();
   21842           0 :   return resultobj;
   21843           0 : fail:
   21844             :   return NULL;
   21845             : }
   21846             : 
   21847             : 
   21848           0 : SWIGINTERN PyObject *_wrap_scalebarObj_label_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21849             :   PyObject *resultobj = 0;
   21850             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21851           0 :   void *argp1 = 0 ;
   21852             :   int res1 = 0 ;
   21853           0 :   PyObject * obj0 = 0 ;
   21854             :   labelObj *result = 0 ;
   21855             :   
   21856           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_label_get",&obj0)) SWIG_fail;
   21857           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21858           0 :   if (!SWIG_IsOK(res1)) {
   21859           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_label_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21860             :   }
   21861           0 :   arg1 = (scalebarObj *)(argp1);
   21862           0 :   result = (labelObj *)& ((arg1)->label);
   21863           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, 0 |  0 );
   21864           0 :   return resultobj;
   21865           0 : fail:
   21866             :   return NULL;
   21867             : }
   21868             : 
   21869             : 
   21870           0 : SWIGINTERN PyObject *_wrap_scalebarObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21871             :   PyObject *resultobj = 0;
   21872             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21873             :   colorObj *arg2 = (colorObj *) 0 ;
   21874           0 :   void *argp1 = 0 ;
   21875             :   int res1 = 0 ;
   21876           0 :   void *argp2 = 0 ;
   21877             :   int res2 = 0 ;
   21878           0 :   PyObject * obj0 = 0 ;
   21879           0 :   PyObject * obj1 = 0 ;
   21880             :   
   21881           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_color_set",&obj0,&obj1)) SWIG_fail;
   21882           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21883           0 :   if (!SWIG_IsOK(res1)) {
   21884           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_color_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21885             :   }
   21886           0 :   arg1 = (scalebarObj *)(argp1);
   21887           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   21888           0 :   if (!SWIG_IsOK(res2)) {
   21889           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_color_set" "', argument " "2"" of type '" "colorObj *""'"); 
   21890             :   }
   21891           0 :   arg2 = (colorObj *)(argp2);
   21892           0 :   if (arg1) (arg1)->color = *arg2;
   21893             :   resultobj = SWIG_Py_Void();
   21894           0 :   return resultobj;
   21895           0 : fail:
   21896             :   return NULL;
   21897             : }
   21898             : 
   21899             : 
   21900           0 : SWIGINTERN PyObject *_wrap_scalebarObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21901             :   PyObject *resultobj = 0;
   21902             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21903           0 :   void *argp1 = 0 ;
   21904             :   int res1 = 0 ;
   21905           0 :   PyObject * obj0 = 0 ;
   21906             :   colorObj *result = 0 ;
   21907             :   
   21908           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_color_get",&obj0)) SWIG_fail;
   21909           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21910           0 :   if (!SWIG_IsOK(res1)) {
   21911           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_color_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21912             :   }
   21913           0 :   arg1 = (scalebarObj *)(argp1);
   21914           0 :   result = (colorObj *)& ((arg1)->color);
   21915           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   21916           0 :   return resultobj;
   21917           0 : fail:
   21918             :   return NULL;
   21919             : }
   21920             : 
   21921             : 
   21922           0 : SWIGINTERN PyObject *_wrap_scalebarObj_backgroundcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21923             :   PyObject *resultobj = 0;
   21924             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21925             :   colorObj *arg2 = (colorObj *) 0 ;
   21926           0 :   void *argp1 = 0 ;
   21927             :   int res1 = 0 ;
   21928           0 :   void *argp2 = 0 ;
   21929             :   int res2 = 0 ;
   21930           0 :   PyObject * obj0 = 0 ;
   21931           0 :   PyObject * obj1 = 0 ;
   21932             :   
   21933           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_backgroundcolor_set",&obj0,&obj1)) SWIG_fail;
   21934           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21935           0 :   if (!SWIG_IsOK(res1)) {
   21936           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_backgroundcolor_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21937             :   }
   21938           0 :   arg1 = (scalebarObj *)(argp1);
   21939           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   21940           0 :   if (!SWIG_IsOK(res2)) {
   21941           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_backgroundcolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   21942             :   }
   21943           0 :   arg2 = (colorObj *)(argp2);
   21944           0 :   if (arg1) (arg1)->backgroundcolor = *arg2;
   21945             :   resultobj = SWIG_Py_Void();
   21946           0 :   return resultobj;
   21947           0 : fail:
   21948             :   return NULL;
   21949             : }
   21950             : 
   21951             : 
   21952           0 : SWIGINTERN PyObject *_wrap_scalebarObj_backgroundcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21953             :   PyObject *resultobj = 0;
   21954             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21955           0 :   void *argp1 = 0 ;
   21956             :   int res1 = 0 ;
   21957           0 :   PyObject * obj0 = 0 ;
   21958             :   colorObj *result = 0 ;
   21959             :   
   21960           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_backgroundcolor_get",&obj0)) SWIG_fail;
   21961           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21962           0 :   if (!SWIG_IsOK(res1)) {
   21963           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_backgroundcolor_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21964             :   }
   21965           0 :   arg1 = (scalebarObj *)(argp1);
   21966           0 :   result = (colorObj *)& ((arg1)->backgroundcolor);
   21967           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   21968           0 :   return resultobj;
   21969           0 : fail:
   21970             :   return NULL;
   21971             : }
   21972             : 
   21973             : 
   21974           0 : SWIGINTERN PyObject *_wrap_scalebarObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   21975             :   PyObject *resultobj = 0;
   21976             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   21977             :   colorObj *arg2 = (colorObj *) 0 ;
   21978           0 :   void *argp1 = 0 ;
   21979             :   int res1 = 0 ;
   21980           0 :   void *argp2 = 0 ;
   21981             :   int res2 = 0 ;
   21982           0 :   PyObject * obj0 = 0 ;
   21983           0 :   PyObject * obj1 = 0 ;
   21984             :   
   21985           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
   21986           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   21987           0 :   if (!SWIG_IsOK(res1)) {
   21988           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_outlinecolor_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   21989             :   }
   21990           0 :   arg1 = (scalebarObj *)(argp1);
   21991           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   21992           0 :   if (!SWIG_IsOK(res2)) {
   21993           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   21994             :   }
   21995           0 :   arg2 = (colorObj *)(argp2);
   21996           0 :   if (arg1) (arg1)->outlinecolor = *arg2;
   21997             :   resultobj = SWIG_Py_Void();
   21998           0 :   return resultobj;
   21999           0 : fail:
   22000             :   return NULL;
   22001             : }
   22002             : 
   22003             : 
   22004           0 : SWIGINTERN PyObject *_wrap_scalebarObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22005             :   PyObject *resultobj = 0;
   22006             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22007           0 :   void *argp1 = 0 ;
   22008             :   int res1 = 0 ;
   22009           0 :   PyObject * obj0 = 0 ;
   22010             :   colorObj *result = 0 ;
   22011             :   
   22012           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_outlinecolor_get",&obj0)) SWIG_fail;
   22013           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22014           0 :   if (!SWIG_IsOK(res1)) {
   22015           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_outlinecolor_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22016             :   }
   22017           0 :   arg1 = (scalebarObj *)(argp1);
   22018           0 :   result = (colorObj *)& ((arg1)->outlinecolor);
   22019           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   22020           0 :   return resultobj;
   22021           0 : fail:
   22022             :   return NULL;
   22023             : }
   22024             : 
   22025             : 
   22026           0 : SWIGINTERN PyObject *_wrap_scalebarObj_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22027             :   PyObject *resultobj = 0;
   22028             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22029             :   int arg2 ;
   22030           0 :   void *argp1 = 0 ;
   22031             :   int res1 = 0 ;
   22032             :   int val2 ;
   22033             :   int ecode2 = 0 ;
   22034           0 :   PyObject * obj0 = 0 ;
   22035           0 :   PyObject * obj1 = 0 ;
   22036             :   
   22037           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_units_set",&obj0,&obj1)) SWIG_fail;
   22038           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22039           0 :   if (!SWIG_IsOK(res1)) {
   22040           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_units_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22041             :   }
   22042           0 :   arg1 = (scalebarObj *)(argp1);
   22043           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22044           0 :   if (!SWIG_IsOK(ecode2)) {
   22045           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_units_set" "', argument " "2"" of type '" "int""'");
   22046             :   } 
   22047             :   arg2 = (int)(val2);
   22048           0 :   if (arg1) (arg1)->units = arg2;
   22049             :   resultobj = SWIG_Py_Void();
   22050           0 :   return resultobj;
   22051           0 : fail:
   22052             :   return NULL;
   22053             : }
   22054             : 
   22055             : 
   22056           0 : SWIGINTERN PyObject *_wrap_scalebarObj_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22057             :   PyObject *resultobj = 0;
   22058             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22059           0 :   void *argp1 = 0 ;
   22060             :   int res1 = 0 ;
   22061           0 :   PyObject * obj0 = 0 ;
   22062             :   int result;
   22063             :   
   22064           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_units_get",&obj0)) SWIG_fail;
   22065           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22066           0 :   if (!SWIG_IsOK(res1)) {
   22067           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_units_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22068             :   }
   22069           0 :   arg1 = (scalebarObj *)(argp1);
   22070           0 :   result = (int) ((arg1)->units);
   22071             :   resultobj = SWIG_From_int((int)(result));
   22072           0 :   return resultobj;
   22073           0 : fail:
   22074             :   return NULL;
   22075             : }
   22076             : 
   22077             : 
   22078           0 : SWIGINTERN PyObject *_wrap_scalebarObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22079             :   PyObject *resultobj = 0;
   22080             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22081             :   int arg2 ;
   22082           0 :   void *argp1 = 0 ;
   22083             :   int res1 = 0 ;
   22084             :   int val2 ;
   22085             :   int ecode2 = 0 ;
   22086           0 :   PyObject * obj0 = 0 ;
   22087           0 :   PyObject * obj1 = 0 ;
   22088             :   
   22089           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_status_set",&obj0,&obj1)) SWIG_fail;
   22090           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22091           0 :   if (!SWIG_IsOK(res1)) {
   22092           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_status_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22093             :   }
   22094           0 :   arg1 = (scalebarObj *)(argp1);
   22095           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22096           0 :   if (!SWIG_IsOK(ecode2)) {
   22097           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_status_set" "', argument " "2"" of type '" "int""'");
   22098             :   } 
   22099             :   arg2 = (int)(val2);
   22100           0 :   if (arg1) (arg1)->status = arg2;
   22101             :   resultobj = SWIG_Py_Void();
   22102           0 :   return resultobj;
   22103           0 : fail:
   22104             :   return NULL;
   22105             : }
   22106             : 
   22107             : 
   22108           0 : SWIGINTERN PyObject *_wrap_scalebarObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22109             :   PyObject *resultobj = 0;
   22110             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22111           0 :   void *argp1 = 0 ;
   22112             :   int res1 = 0 ;
   22113           0 :   PyObject * obj0 = 0 ;
   22114             :   int result;
   22115             :   
   22116           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_status_get",&obj0)) SWIG_fail;
   22117           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22118           0 :   if (!SWIG_IsOK(res1)) {
   22119           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_status_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22120             :   }
   22121           0 :   arg1 = (scalebarObj *)(argp1);
   22122           0 :   result = (int) ((arg1)->status);
   22123             :   resultobj = SWIG_From_int((int)(result));
   22124           0 :   return resultobj;
   22125           0 : fail:
   22126             :   return NULL;
   22127             : }
   22128             : 
   22129             : 
   22130           0 : SWIGINTERN PyObject *_wrap_scalebarObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22131             :   PyObject *resultobj = 0;
   22132             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22133             :   int arg2 ;
   22134           0 :   void *argp1 = 0 ;
   22135             :   int res1 = 0 ;
   22136             :   int val2 ;
   22137             :   int ecode2 = 0 ;
   22138           0 :   PyObject * obj0 = 0 ;
   22139           0 :   PyObject * obj1 = 0 ;
   22140             :   
   22141           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_position_set",&obj0,&obj1)) SWIG_fail;
   22142           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22143           0 :   if (!SWIG_IsOK(res1)) {
   22144           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_position_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22145             :   }
   22146           0 :   arg1 = (scalebarObj *)(argp1);
   22147           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22148           0 :   if (!SWIG_IsOK(ecode2)) {
   22149           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_position_set" "', argument " "2"" of type '" "int""'");
   22150             :   } 
   22151             :   arg2 = (int)(val2);
   22152           0 :   if (arg1) (arg1)->position = arg2;
   22153             :   resultobj = SWIG_Py_Void();
   22154           0 :   return resultobj;
   22155           0 : fail:
   22156             :   return NULL;
   22157             : }
   22158             : 
   22159             : 
   22160           0 : SWIGINTERN PyObject *_wrap_scalebarObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22161             :   PyObject *resultobj = 0;
   22162             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22163           0 :   void *argp1 = 0 ;
   22164             :   int res1 = 0 ;
   22165           0 :   PyObject * obj0 = 0 ;
   22166             :   int result;
   22167             :   
   22168           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_position_get",&obj0)) SWIG_fail;
   22169           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22170           0 :   if (!SWIG_IsOK(res1)) {
   22171           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_position_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22172             :   }
   22173           0 :   arg1 = (scalebarObj *)(argp1);
   22174           0 :   result = (int) ((arg1)->position);
   22175             :   resultobj = SWIG_From_int((int)(result));
   22176           0 :   return resultobj;
   22177           0 : fail:
   22178             :   return NULL;
   22179             : }
   22180             : 
   22181             : 
   22182           0 : SWIGINTERN PyObject *_wrap_scalebarObj_postlabelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22183             :   PyObject *resultobj = 0;
   22184             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22185             :   int arg2 ;
   22186           0 :   void *argp1 = 0 ;
   22187             :   int res1 = 0 ;
   22188             :   int val2 ;
   22189             :   int ecode2 = 0 ;
   22190           0 :   PyObject * obj0 = 0 ;
   22191           0 :   PyObject * obj1 = 0 ;
   22192             :   
   22193           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_postlabelcache_set",&obj0,&obj1)) SWIG_fail;
   22194           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22195           0 :   if (!SWIG_IsOK(res1)) {
   22196           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_postlabelcache_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22197             :   }
   22198           0 :   arg1 = (scalebarObj *)(argp1);
   22199           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22200           0 :   if (!SWIG_IsOK(ecode2)) {
   22201           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_postlabelcache_set" "', argument " "2"" of type '" "int""'");
   22202             :   } 
   22203             :   arg2 = (int)(val2);
   22204           0 :   if (arg1) (arg1)->postlabelcache = arg2;
   22205             :   resultobj = SWIG_Py_Void();
   22206           0 :   return resultobj;
   22207           0 : fail:
   22208             :   return NULL;
   22209             : }
   22210             : 
   22211             : 
   22212           0 : SWIGINTERN PyObject *_wrap_scalebarObj_postlabelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22213             :   PyObject *resultobj = 0;
   22214             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22215           0 :   void *argp1 = 0 ;
   22216             :   int res1 = 0 ;
   22217           0 :   PyObject * obj0 = 0 ;
   22218             :   int result;
   22219             :   
   22220           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_postlabelcache_get",&obj0)) SWIG_fail;
   22221           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22222           0 :   if (!SWIG_IsOK(res1)) {
   22223           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_postlabelcache_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22224             :   }
   22225           0 :   arg1 = (scalebarObj *)(argp1);
   22226           0 :   result = (int) ((arg1)->postlabelcache);
   22227             :   resultobj = SWIG_From_int((int)(result));
   22228           0 :   return resultobj;
   22229           0 : fail:
   22230             :   return NULL;
   22231             : }
   22232             : 
   22233             : 
   22234           0 : SWIGINTERN PyObject *_wrap_scalebarObj_align_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22235             :   PyObject *resultobj = 0;
   22236             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22237             :   int arg2 ;
   22238           0 :   void *argp1 = 0 ;
   22239             :   int res1 = 0 ;
   22240             :   int val2 ;
   22241             :   int ecode2 = 0 ;
   22242           0 :   PyObject * obj0 = 0 ;
   22243           0 :   PyObject * obj1 = 0 ;
   22244             :   
   22245           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_align_set",&obj0,&obj1)) SWIG_fail;
   22246           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22247           0 :   if (!SWIG_IsOK(res1)) {
   22248           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_align_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22249             :   }
   22250           0 :   arg1 = (scalebarObj *)(argp1);
   22251           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22252           0 :   if (!SWIG_IsOK(ecode2)) {
   22253           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_align_set" "', argument " "2"" of type '" "int""'");
   22254             :   } 
   22255             :   arg2 = (int)(val2);
   22256           0 :   if (arg1) (arg1)->align = arg2;
   22257             :   resultobj = SWIG_Py_Void();
   22258           0 :   return resultobj;
   22259           0 : fail:
   22260             :   return NULL;
   22261             : }
   22262             : 
   22263             : 
   22264           0 : SWIGINTERN PyObject *_wrap_scalebarObj_align_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22265             :   PyObject *resultobj = 0;
   22266             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22267           0 :   void *argp1 = 0 ;
   22268             :   int res1 = 0 ;
   22269           0 :   PyObject * obj0 = 0 ;
   22270             :   int result;
   22271             :   
   22272           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_align_get",&obj0)) SWIG_fail;
   22273           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22274           0 :   if (!SWIG_IsOK(res1)) {
   22275           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_align_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22276             :   }
   22277           0 :   arg1 = (scalebarObj *)(argp1);
   22278           0 :   result = (int) ((arg1)->align);
   22279             :   resultobj = SWIG_From_int((int)(result));
   22280           0 :   return resultobj;
   22281           0 : fail:
   22282             :   return NULL;
   22283             : }
   22284             : 
   22285             : 
   22286           0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsetx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22287             :   PyObject *resultobj = 0;
   22288             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22289             :   int arg2 ;
   22290           0 :   void *argp1 = 0 ;
   22291             :   int res1 = 0 ;
   22292             :   int val2 ;
   22293             :   int ecode2 = 0 ;
   22294           0 :   PyObject * obj0 = 0 ;
   22295           0 :   PyObject * obj1 = 0 ;
   22296             :   
   22297           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_offsetx_set",&obj0,&obj1)) SWIG_fail;
   22298           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22299           0 :   if (!SWIG_IsOK(res1)) {
   22300           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsetx_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22301             :   }
   22302           0 :   arg1 = (scalebarObj *)(argp1);
   22303           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22304           0 :   if (!SWIG_IsOK(ecode2)) {
   22305           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_offsetx_set" "', argument " "2"" of type '" "int""'");
   22306             :   } 
   22307             :   arg2 = (int)(val2);
   22308           0 :   if (arg1) (arg1)->offsetx = arg2;
   22309             :   resultobj = SWIG_Py_Void();
   22310           0 :   return resultobj;
   22311           0 : fail:
   22312             :   return NULL;
   22313             : }
   22314             : 
   22315             : 
   22316           0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsetx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22317             :   PyObject *resultobj = 0;
   22318             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22319           0 :   void *argp1 = 0 ;
   22320             :   int res1 = 0 ;
   22321           0 :   PyObject * obj0 = 0 ;
   22322             :   int result;
   22323             :   
   22324           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_offsetx_get",&obj0)) SWIG_fail;
   22325           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22326           0 :   if (!SWIG_IsOK(res1)) {
   22327           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsetx_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22328             :   }
   22329           0 :   arg1 = (scalebarObj *)(argp1);
   22330           0 :   result = (int) ((arg1)->offsetx);
   22331             :   resultobj = SWIG_From_int((int)(result));
   22332           0 :   return resultobj;
   22333           0 : fail:
   22334             :   return NULL;
   22335             : }
   22336             : 
   22337             : 
   22338           0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsety_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22339             :   PyObject *resultobj = 0;
   22340             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22341             :   int arg2 ;
   22342           0 :   void *argp1 = 0 ;
   22343             :   int res1 = 0 ;
   22344             :   int val2 ;
   22345             :   int ecode2 = 0 ;
   22346           0 :   PyObject * obj0 = 0 ;
   22347           0 :   PyObject * obj1 = 0 ;
   22348             :   
   22349           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_offsety_set",&obj0,&obj1)) SWIG_fail;
   22350           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22351           0 :   if (!SWIG_IsOK(res1)) {
   22352           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsety_set" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22353             :   }
   22354           0 :   arg1 = (scalebarObj *)(argp1);
   22355           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22356           0 :   if (!SWIG_IsOK(ecode2)) {
   22357           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_offsety_set" "', argument " "2"" of type '" "int""'");
   22358             :   } 
   22359             :   arg2 = (int)(val2);
   22360           0 :   if (arg1) (arg1)->offsety = arg2;
   22361             :   resultobj = SWIG_Py_Void();
   22362           0 :   return resultobj;
   22363           0 : fail:
   22364             :   return NULL;
   22365             : }
   22366             : 
   22367             : 
   22368           0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsety_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22369             :   PyObject *resultobj = 0;
   22370             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22371           0 :   void *argp1 = 0 ;
   22372             :   int res1 = 0 ;
   22373           0 :   PyObject * obj0 = 0 ;
   22374             :   int result;
   22375             :   
   22376           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_offsety_get",&obj0)) SWIG_fail;
   22377           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22378           0 :   if (!SWIG_IsOK(res1)) {
   22379           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsety_get" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22380             :   }
   22381           0 :   arg1 = (scalebarObj *)(argp1);
   22382           0 :   result = (int) ((arg1)->offsety);
   22383             :   resultobj = SWIG_From_int((int)(result));
   22384           0 :   return resultobj;
   22385           0 : fail:
   22386             :   return NULL;
   22387             : }
   22388             : 
   22389             : 
   22390           0 : SWIGINTERN PyObject *_wrap_scalebarObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22391             :   PyObject *resultobj = 0;
   22392             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22393             :   char *arg2 = (char *) 0 ;
   22394           0 :   void *argp1 = 0 ;
   22395             :   int res1 = 0 ;
   22396             :   int res2 ;
   22397           0 :   char *buf2 = 0 ;
   22398           0 :   int alloc2 = 0 ;
   22399           0 :   PyObject * obj0 = 0 ;
   22400           0 :   PyObject * obj1 = 0 ;
   22401             :   int result;
   22402             :   
   22403           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   22404           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22405           0 :   if (!SWIG_IsOK(res1)) {
   22406           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_updateFromString" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22407             :   }
   22408           0 :   arg1 = (scalebarObj *)(argp1);
   22409           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   22410           0 :   if (!SWIG_IsOK(res2)) {
   22411           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   22412             :   }
   22413           0 :   arg2 = (char *)(buf2);
   22414             :   {
   22415             :     result = (int)scalebarObj_updateFromString(arg1,arg2); {
   22416           0 :       errorObj *ms_error = msGetErrorObj();
   22417             :       
   22418           0 :       switch(ms_error->code) {
   22419             :       case MS_NOERR:
   22420             :         break;
   22421           0 :       case MS_NOTFOUND:
   22422           0 :         msResetErrorList();
   22423           0 :         break;
   22424             :       case -1:
   22425             :         break;
   22426           0 :       case MS_IOERR:
   22427           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   22428           0 :           _raise_ms_exception();
   22429           0 :           msResetErrorList();
   22430           0 :           return NULL;
   22431             :         }
   22432             :       default:
   22433           0 :         _raise_ms_exception();
   22434           0 :         msResetErrorList();
   22435           0 :         return NULL;
   22436             :       }
   22437             :       
   22438             :     }
   22439             :   }
   22440             :   resultobj = SWIG_From_int((int)(result));
   22441           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   22442             :   return resultobj;
   22443           0 : fail:
   22444           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   22445             :   return NULL;
   22446             : }
   22447             : 
   22448             : 
   22449           0 : SWIGINTERN PyObject *_wrap_scalebarObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22450             :   PyObject *resultobj = 0;
   22451             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22452           0 :   void *argp1 = 0 ;
   22453             :   int res1 = 0 ;
   22454           0 :   PyObject * obj0 = 0 ;
   22455             :   char *result = 0 ;
   22456             :   
   22457           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_convertToString",&obj0)) SWIG_fail;
   22458           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 |  0 );
   22459           0 :   if (!SWIG_IsOK(res1)) {
   22460           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_convertToString" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22461             :   }
   22462           0 :   arg1 = (scalebarObj *)(argp1);
   22463             :   {
   22464             :     result = (char *)scalebarObj_convertToString(arg1); {
   22465           0 :       errorObj *ms_error = msGetErrorObj();
   22466             :       
   22467           0 :       switch(ms_error->code) {
   22468             :       case MS_NOERR:
   22469             :         break;
   22470           0 :       case MS_NOTFOUND:
   22471           0 :         msResetErrorList();
   22472           0 :         break;
   22473             :       case -1:
   22474             :         break;
   22475           0 :       case MS_IOERR:
   22476           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   22477           0 :           _raise_ms_exception();
   22478           0 :           msResetErrorList();
   22479           0 :           return NULL;
   22480             :         }
   22481             :       default:
   22482           0 :         _raise_ms_exception();
   22483           0 :         msResetErrorList();
   22484           0 :         return NULL;
   22485             :       }
   22486             :       
   22487             :     }
   22488             :   }
   22489           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   22490           0 :   free((char*)result);
   22491           0 :   return resultobj;
   22492           0 : fail:
   22493             :   return NULL;
   22494             : }
   22495             : 
   22496             : 
   22497           0 : SWIGINTERN PyObject *_wrap_new_scalebarObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22498             :   PyObject *resultobj = 0;
   22499             :   scalebarObj *result = 0 ;
   22500             :   
   22501           0 :   if (!PyArg_ParseTuple(args,(char *)":new_scalebarObj")) SWIG_fail;
   22502             :   {
   22503           0 :     result = (scalebarObj *)calloc(1, sizeof(scalebarObj)); {
   22504           0 :       errorObj *ms_error = msGetErrorObj();
   22505             :       
   22506           0 :       switch(ms_error->code) {
   22507             :       case MS_NOERR:
   22508             :         break;
   22509           0 :       case MS_NOTFOUND:
   22510           0 :         msResetErrorList();
   22511           0 :         break;
   22512             :       case -1:
   22513             :         break;
   22514           0 :       case MS_IOERR:
   22515           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   22516           0 :           _raise_ms_exception();
   22517           0 :           msResetErrorList();
   22518           0 :           return NULL;
   22519             :         }
   22520             :       default:
   22521           0 :         _raise_ms_exception();
   22522           0 :         msResetErrorList();
   22523           0 :         return NULL;
   22524             :       }
   22525             :       
   22526             :     }
   22527             :   }
   22528           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scalebarObj, SWIG_POINTER_NEW |  0 );
   22529           0 :   return resultobj;
   22530           0 : fail:
   22531             :   return NULL;
   22532             : }
   22533             : 
   22534             : 
   22535           0 : SWIGINTERN PyObject *_wrap_delete_scalebarObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22536             :   PyObject *resultobj = 0;
   22537             :   scalebarObj *arg1 = (scalebarObj *) 0 ;
   22538           0 :   void *argp1 = 0 ;
   22539             :   int res1 = 0 ;
   22540           0 :   PyObject * obj0 = 0 ;
   22541             :   
   22542           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_scalebarObj",&obj0)) SWIG_fail;
   22543           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, SWIG_POINTER_DISOWN |  0 );
   22544           0 :   if (!SWIG_IsOK(res1)) {
   22545           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scalebarObj" "', argument " "1"" of type '" "scalebarObj *""'"); 
   22546             :   }
   22547           0 :   arg1 = (scalebarObj *)(argp1);
   22548             :   {
   22549           0 :     free((char *) arg1); {
   22550           0 :       errorObj *ms_error = msGetErrorObj();
   22551             :       
   22552           0 :       switch(ms_error->code) {
   22553             :       case MS_NOERR:
   22554             :         break;
   22555           0 :       case MS_NOTFOUND:
   22556           0 :         msResetErrorList();
   22557           0 :         break;
   22558             :       case -1:
   22559             :         break;
   22560           0 :       case MS_IOERR:
   22561           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   22562           0 :           _raise_ms_exception();
   22563           0 :           msResetErrorList();
   22564           0 :           return NULL;
   22565             :         }
   22566             :       default:
   22567           0 :         _raise_ms_exception();
   22568           0 :         msResetErrorList();
   22569           0 :         return NULL;
   22570             :       }
   22571             :       
   22572             :     }
   22573             :   }
   22574             :   resultobj = SWIG_Py_Void();
   22575           0 :   return resultobj;
   22576           0 : fail:
   22577             :   return NULL;
   22578             : }
   22579             : 
   22580             : 
   22581           1 : SWIGINTERN PyObject *scalebarObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22582             :   PyObject *obj;
   22583           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   22584           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_scalebarObj, SWIG_NewClientData(obj));
   22585           1 :   return SWIG_Py_Void();
   22586             : }
   22587             : 
   22588           0 : SWIGINTERN PyObject *_wrap_legendObj_imagecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22589             :   PyObject *resultobj = 0;
   22590             :   legendObj *arg1 = (legendObj *) 0 ;
   22591             :   colorObj *arg2 = (colorObj *) 0 ;
   22592           0 :   void *argp1 = 0 ;
   22593             :   int res1 = 0 ;
   22594           0 :   void *argp2 = 0 ;
   22595             :   int res2 = 0 ;
   22596           0 :   PyObject * obj0 = 0 ;
   22597           0 :   PyObject * obj1 = 0 ;
   22598             :   
   22599           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_imagecolor_set",&obj0,&obj1)) SWIG_fail;
   22600           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22601           0 :   if (!SWIG_IsOK(res1)) {
   22602           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_imagecolor_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22603             :   }
   22604           0 :   arg1 = (legendObj *)(argp1);
   22605           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   22606           0 :   if (!SWIG_IsOK(res2)) {
   22607           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_imagecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   22608             :   }
   22609           0 :   arg2 = (colorObj *)(argp2);
   22610           0 :   if (arg1) (arg1)->imagecolor = *arg2;
   22611             :   resultobj = SWIG_Py_Void();
   22612           0 :   return resultobj;
   22613           0 : fail:
   22614             :   return NULL;
   22615             : }
   22616             : 
   22617             : 
   22618           0 : SWIGINTERN PyObject *_wrap_legendObj_imagecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22619             :   PyObject *resultobj = 0;
   22620             :   legendObj *arg1 = (legendObj *) 0 ;
   22621           0 :   void *argp1 = 0 ;
   22622             :   int res1 = 0 ;
   22623           0 :   PyObject * obj0 = 0 ;
   22624             :   colorObj *result = 0 ;
   22625             :   
   22626           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_imagecolor_get",&obj0)) SWIG_fail;
   22627           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22628           0 :   if (!SWIG_IsOK(res1)) {
   22629           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_imagecolor_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22630             :   }
   22631           0 :   arg1 = (legendObj *)(argp1);
   22632           0 :   result = (colorObj *)& ((arg1)->imagecolor);
   22633           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   22634           0 :   return resultobj;
   22635           0 : fail:
   22636             :   return NULL;
   22637             : }
   22638             : 
   22639             : 
   22640           0 : SWIGINTERN PyObject *_wrap_legendObj_label_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22641             :   PyObject *resultobj = 0;
   22642             :   legendObj *arg1 = (legendObj *) 0 ;
   22643           0 :   void *argp1 = 0 ;
   22644             :   int res1 = 0 ;
   22645           0 :   PyObject * obj0 = 0 ;
   22646             :   labelObj *result = 0 ;
   22647             :   
   22648           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_label_get",&obj0)) SWIG_fail;
   22649           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22650           0 :   if (!SWIG_IsOK(res1)) {
   22651           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_label_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22652             :   }
   22653           0 :   arg1 = (legendObj *)(argp1);
   22654           0 :   result = (labelObj *)& ((arg1)->label);
   22655           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, 0 |  0 );
   22656           0 :   return resultobj;
   22657           0 : fail:
   22658             :   return NULL;
   22659             : }
   22660             : 
   22661             : 
   22662           0 : SWIGINTERN PyObject *_wrap_legendObj_keysizex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22663             :   PyObject *resultobj = 0;
   22664             :   legendObj *arg1 = (legendObj *) 0 ;
   22665             :   int arg2 ;
   22666           0 :   void *argp1 = 0 ;
   22667             :   int res1 = 0 ;
   22668             :   int val2 ;
   22669             :   int ecode2 = 0 ;
   22670           0 :   PyObject * obj0 = 0 ;
   22671           0 :   PyObject * obj1 = 0 ;
   22672             :   
   22673           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keysizex_set",&obj0,&obj1)) SWIG_fail;
   22674           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22675           0 :   if (!SWIG_IsOK(res1)) {
   22676           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizex_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22677             :   }
   22678           0 :   arg1 = (legendObj *)(argp1);
   22679           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22680           0 :   if (!SWIG_IsOK(ecode2)) {
   22681           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keysizex_set" "', argument " "2"" of type '" "int""'");
   22682             :   } 
   22683             :   arg2 = (int)(val2);
   22684           0 :   if (arg1) (arg1)->keysizex = arg2;
   22685             :   resultobj = SWIG_Py_Void();
   22686           0 :   return resultobj;
   22687           0 : fail:
   22688             :   return NULL;
   22689             : }
   22690             : 
   22691             : 
   22692           0 : SWIGINTERN PyObject *_wrap_legendObj_keysizex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22693             :   PyObject *resultobj = 0;
   22694             :   legendObj *arg1 = (legendObj *) 0 ;
   22695           0 :   void *argp1 = 0 ;
   22696             :   int res1 = 0 ;
   22697           0 :   PyObject * obj0 = 0 ;
   22698             :   int result;
   22699             :   
   22700           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keysizex_get",&obj0)) SWIG_fail;
   22701           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22702           0 :   if (!SWIG_IsOK(res1)) {
   22703           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizex_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22704             :   }
   22705           0 :   arg1 = (legendObj *)(argp1);
   22706           0 :   result = (int) ((arg1)->keysizex);
   22707             :   resultobj = SWIG_From_int((int)(result));
   22708           0 :   return resultobj;
   22709           0 : fail:
   22710             :   return NULL;
   22711             : }
   22712             : 
   22713             : 
   22714           0 : SWIGINTERN PyObject *_wrap_legendObj_keysizey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22715             :   PyObject *resultobj = 0;
   22716             :   legendObj *arg1 = (legendObj *) 0 ;
   22717             :   int arg2 ;
   22718           0 :   void *argp1 = 0 ;
   22719             :   int res1 = 0 ;
   22720             :   int val2 ;
   22721             :   int ecode2 = 0 ;
   22722           0 :   PyObject * obj0 = 0 ;
   22723           0 :   PyObject * obj1 = 0 ;
   22724             :   
   22725           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keysizey_set",&obj0,&obj1)) SWIG_fail;
   22726           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22727           0 :   if (!SWIG_IsOK(res1)) {
   22728           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizey_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22729             :   }
   22730           0 :   arg1 = (legendObj *)(argp1);
   22731           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22732           0 :   if (!SWIG_IsOK(ecode2)) {
   22733           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keysizey_set" "', argument " "2"" of type '" "int""'");
   22734             :   } 
   22735             :   arg2 = (int)(val2);
   22736           0 :   if (arg1) (arg1)->keysizey = arg2;
   22737             :   resultobj = SWIG_Py_Void();
   22738           0 :   return resultobj;
   22739           0 : fail:
   22740             :   return NULL;
   22741             : }
   22742             : 
   22743             : 
   22744           0 : SWIGINTERN PyObject *_wrap_legendObj_keysizey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22745             :   PyObject *resultobj = 0;
   22746             :   legendObj *arg1 = (legendObj *) 0 ;
   22747           0 :   void *argp1 = 0 ;
   22748             :   int res1 = 0 ;
   22749           0 :   PyObject * obj0 = 0 ;
   22750             :   int result;
   22751             :   
   22752           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keysizey_get",&obj0)) SWIG_fail;
   22753           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22754           0 :   if (!SWIG_IsOK(res1)) {
   22755           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizey_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22756             :   }
   22757           0 :   arg1 = (legendObj *)(argp1);
   22758           0 :   result = (int) ((arg1)->keysizey);
   22759             :   resultobj = SWIG_From_int((int)(result));
   22760           0 :   return resultobj;
   22761           0 : fail:
   22762             :   return NULL;
   22763             : }
   22764             : 
   22765             : 
   22766           0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22767             :   PyObject *resultobj = 0;
   22768             :   legendObj *arg1 = (legendObj *) 0 ;
   22769             :   int arg2 ;
   22770           0 :   void *argp1 = 0 ;
   22771             :   int res1 = 0 ;
   22772             :   int val2 ;
   22773             :   int ecode2 = 0 ;
   22774           0 :   PyObject * obj0 = 0 ;
   22775           0 :   PyObject * obj1 = 0 ;
   22776             :   
   22777           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keyspacingx_set",&obj0,&obj1)) SWIG_fail;
   22778           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22779           0 :   if (!SWIG_IsOK(res1)) {
   22780           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingx_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22781             :   }
   22782           0 :   arg1 = (legendObj *)(argp1);
   22783           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22784           0 :   if (!SWIG_IsOK(ecode2)) {
   22785           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keyspacingx_set" "', argument " "2"" of type '" "int""'");
   22786             :   } 
   22787             :   arg2 = (int)(val2);
   22788           0 :   if (arg1) (arg1)->keyspacingx = arg2;
   22789             :   resultobj = SWIG_Py_Void();
   22790           0 :   return resultobj;
   22791           0 : fail:
   22792             :   return NULL;
   22793             : }
   22794             : 
   22795             : 
   22796           0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22797             :   PyObject *resultobj = 0;
   22798             :   legendObj *arg1 = (legendObj *) 0 ;
   22799           0 :   void *argp1 = 0 ;
   22800             :   int res1 = 0 ;
   22801           0 :   PyObject * obj0 = 0 ;
   22802             :   int result;
   22803             :   
   22804           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keyspacingx_get",&obj0)) SWIG_fail;
   22805           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22806           0 :   if (!SWIG_IsOK(res1)) {
   22807           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingx_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22808             :   }
   22809           0 :   arg1 = (legendObj *)(argp1);
   22810           0 :   result = (int) ((arg1)->keyspacingx);
   22811             :   resultobj = SWIG_From_int((int)(result));
   22812           0 :   return resultobj;
   22813           0 : fail:
   22814             :   return NULL;
   22815             : }
   22816             : 
   22817             : 
   22818           0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22819             :   PyObject *resultobj = 0;
   22820             :   legendObj *arg1 = (legendObj *) 0 ;
   22821             :   int arg2 ;
   22822           0 :   void *argp1 = 0 ;
   22823             :   int res1 = 0 ;
   22824             :   int val2 ;
   22825             :   int ecode2 = 0 ;
   22826           0 :   PyObject * obj0 = 0 ;
   22827           0 :   PyObject * obj1 = 0 ;
   22828             :   
   22829           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keyspacingy_set",&obj0,&obj1)) SWIG_fail;
   22830           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22831           0 :   if (!SWIG_IsOK(res1)) {
   22832           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingy_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22833             :   }
   22834           0 :   arg1 = (legendObj *)(argp1);
   22835           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22836           0 :   if (!SWIG_IsOK(ecode2)) {
   22837           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keyspacingy_set" "', argument " "2"" of type '" "int""'");
   22838             :   } 
   22839             :   arg2 = (int)(val2);
   22840           0 :   if (arg1) (arg1)->keyspacingy = arg2;
   22841             :   resultobj = SWIG_Py_Void();
   22842           0 :   return resultobj;
   22843           0 : fail:
   22844             :   return NULL;
   22845             : }
   22846             : 
   22847             : 
   22848           0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22849             :   PyObject *resultobj = 0;
   22850             :   legendObj *arg1 = (legendObj *) 0 ;
   22851           0 :   void *argp1 = 0 ;
   22852             :   int res1 = 0 ;
   22853           0 :   PyObject * obj0 = 0 ;
   22854             :   int result;
   22855             :   
   22856           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keyspacingy_get",&obj0)) SWIG_fail;
   22857           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22858           0 :   if (!SWIG_IsOK(res1)) {
   22859           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingy_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22860             :   }
   22861           0 :   arg1 = (legendObj *)(argp1);
   22862           0 :   result = (int) ((arg1)->keyspacingy);
   22863             :   resultobj = SWIG_From_int((int)(result));
   22864           0 :   return resultobj;
   22865           0 : fail:
   22866             :   return NULL;
   22867             : }
   22868             : 
   22869             : 
   22870           0 : SWIGINTERN PyObject *_wrap_legendObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22871             :   PyObject *resultobj = 0;
   22872             :   legendObj *arg1 = (legendObj *) 0 ;
   22873             :   colorObj *arg2 = (colorObj *) 0 ;
   22874           0 :   void *argp1 = 0 ;
   22875             :   int res1 = 0 ;
   22876           0 :   void *argp2 = 0 ;
   22877             :   int res2 = 0 ;
   22878           0 :   PyObject * obj0 = 0 ;
   22879           0 :   PyObject * obj1 = 0 ;
   22880             :   
   22881           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
   22882           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22883           0 :   if (!SWIG_IsOK(res1)) {
   22884           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_outlinecolor_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22885             :   }
   22886           0 :   arg1 = (legendObj *)(argp1);
   22887           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   22888           0 :   if (!SWIG_IsOK(res2)) {
   22889           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   22890             :   }
   22891           0 :   arg2 = (colorObj *)(argp2);
   22892           0 :   if (arg1) (arg1)->outlinecolor = *arg2;
   22893             :   resultobj = SWIG_Py_Void();
   22894           0 :   return resultobj;
   22895           0 : fail:
   22896             :   return NULL;
   22897             : }
   22898             : 
   22899             : 
   22900           0 : SWIGINTERN PyObject *_wrap_legendObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22901             :   PyObject *resultobj = 0;
   22902             :   legendObj *arg1 = (legendObj *) 0 ;
   22903           0 :   void *argp1 = 0 ;
   22904             :   int res1 = 0 ;
   22905           0 :   PyObject * obj0 = 0 ;
   22906             :   colorObj *result = 0 ;
   22907             :   
   22908           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_outlinecolor_get",&obj0)) SWIG_fail;
   22909           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22910           0 :   if (!SWIG_IsOK(res1)) {
   22911           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_outlinecolor_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22912             :   }
   22913           0 :   arg1 = (legendObj *)(argp1);
   22914           0 :   result = (colorObj *)& ((arg1)->outlinecolor);
   22915           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   22916           0 :   return resultobj;
   22917           0 : fail:
   22918             :   return NULL;
   22919             : }
   22920             : 
   22921             : 
   22922           0 : SWIGINTERN PyObject *_wrap_legendObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22923             :   PyObject *resultobj = 0;
   22924             :   legendObj *arg1 = (legendObj *) 0 ;
   22925             :   int arg2 ;
   22926           0 :   void *argp1 = 0 ;
   22927             :   int res1 = 0 ;
   22928             :   int val2 ;
   22929             :   int ecode2 = 0 ;
   22930           0 :   PyObject * obj0 = 0 ;
   22931           0 :   PyObject * obj1 = 0 ;
   22932             :   
   22933           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_status_set",&obj0,&obj1)) SWIG_fail;
   22934           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22935           0 :   if (!SWIG_IsOK(res1)) {
   22936           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_status_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22937             :   }
   22938           0 :   arg1 = (legendObj *)(argp1);
   22939           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22940           0 :   if (!SWIG_IsOK(ecode2)) {
   22941           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_status_set" "', argument " "2"" of type '" "int""'");
   22942             :   } 
   22943             :   arg2 = (int)(val2);
   22944           0 :   if (arg1) (arg1)->status = arg2;
   22945             :   resultobj = SWIG_Py_Void();
   22946           0 :   return resultobj;
   22947           0 : fail:
   22948             :   return NULL;
   22949             : }
   22950             : 
   22951             : 
   22952           0 : SWIGINTERN PyObject *_wrap_legendObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22953             :   PyObject *resultobj = 0;
   22954             :   legendObj *arg1 = (legendObj *) 0 ;
   22955           0 :   void *argp1 = 0 ;
   22956             :   int res1 = 0 ;
   22957           0 :   PyObject * obj0 = 0 ;
   22958             :   int result;
   22959             :   
   22960           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_status_get",&obj0)) SWIG_fail;
   22961           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22962           0 :   if (!SWIG_IsOK(res1)) {
   22963           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_status_get" "', argument " "1"" of type '" "legendObj *""'"); 
   22964             :   }
   22965           0 :   arg1 = (legendObj *)(argp1);
   22966           0 :   result = (int) ((arg1)->status);
   22967             :   resultobj = SWIG_From_int((int)(result));
   22968           0 :   return resultobj;
   22969           0 : fail:
   22970             :   return NULL;
   22971             : }
   22972             : 
   22973             : 
   22974           0 : SWIGINTERN PyObject *_wrap_legendObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   22975             :   PyObject *resultobj = 0;
   22976             :   legendObj *arg1 = (legendObj *) 0 ;
   22977             :   int arg2 ;
   22978           0 :   void *argp1 = 0 ;
   22979             :   int res1 = 0 ;
   22980             :   int val2 ;
   22981             :   int ecode2 = 0 ;
   22982           0 :   PyObject * obj0 = 0 ;
   22983           0 :   PyObject * obj1 = 0 ;
   22984             :   
   22985           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_height_set",&obj0,&obj1)) SWIG_fail;
   22986           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   22987           0 :   if (!SWIG_IsOK(res1)) {
   22988           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_height_set" "', argument " "1"" of type '" "legendObj *""'"); 
   22989             :   }
   22990           0 :   arg1 = (legendObj *)(argp1);
   22991           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   22992           0 :   if (!SWIG_IsOK(ecode2)) {
   22993           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_height_set" "', argument " "2"" of type '" "int""'");
   22994             :   } 
   22995             :   arg2 = (int)(val2);
   22996           0 :   if (arg1) (arg1)->height = arg2;
   22997             :   resultobj = SWIG_Py_Void();
   22998           0 :   return resultobj;
   22999           0 : fail:
   23000             :   return NULL;
   23001             : }
   23002             : 
   23003             : 
   23004           0 : SWIGINTERN PyObject *_wrap_legendObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23005             :   PyObject *resultobj = 0;
   23006             :   legendObj *arg1 = (legendObj *) 0 ;
   23007           0 :   void *argp1 = 0 ;
   23008             :   int res1 = 0 ;
   23009           0 :   PyObject * obj0 = 0 ;
   23010             :   int result;
   23011             :   
   23012           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_height_get",&obj0)) SWIG_fail;
   23013           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23014           0 :   if (!SWIG_IsOK(res1)) {
   23015           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_height_get" "', argument " "1"" of type '" "legendObj *""'"); 
   23016             :   }
   23017           0 :   arg1 = (legendObj *)(argp1);
   23018           0 :   result = (int) ((arg1)->height);
   23019             :   resultobj = SWIG_From_int((int)(result));
   23020           0 :   return resultobj;
   23021           0 : fail:
   23022             :   return NULL;
   23023             : }
   23024             : 
   23025             : 
   23026           0 : SWIGINTERN PyObject *_wrap_legendObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23027             :   PyObject *resultobj = 0;
   23028             :   legendObj *arg1 = (legendObj *) 0 ;
   23029             :   int arg2 ;
   23030           0 :   void *argp1 = 0 ;
   23031             :   int res1 = 0 ;
   23032             :   int val2 ;
   23033             :   int ecode2 = 0 ;
   23034           0 :   PyObject * obj0 = 0 ;
   23035           0 :   PyObject * obj1 = 0 ;
   23036             :   
   23037           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_width_set",&obj0,&obj1)) SWIG_fail;
   23038           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23039           0 :   if (!SWIG_IsOK(res1)) {
   23040           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_width_set" "', argument " "1"" of type '" "legendObj *""'"); 
   23041             :   }
   23042           0 :   arg1 = (legendObj *)(argp1);
   23043           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   23044           0 :   if (!SWIG_IsOK(ecode2)) {
   23045           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_width_set" "', argument " "2"" of type '" "int""'");
   23046             :   } 
   23047             :   arg2 = (int)(val2);
   23048           0 :   if (arg1) (arg1)->width = arg2;
   23049             :   resultobj = SWIG_Py_Void();
   23050           0 :   return resultobj;
   23051           0 : fail:
   23052             :   return NULL;
   23053             : }
   23054             : 
   23055             : 
   23056           0 : SWIGINTERN PyObject *_wrap_legendObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23057             :   PyObject *resultobj = 0;
   23058             :   legendObj *arg1 = (legendObj *) 0 ;
   23059           0 :   void *argp1 = 0 ;
   23060             :   int res1 = 0 ;
   23061           0 :   PyObject * obj0 = 0 ;
   23062             :   int result;
   23063             :   
   23064           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_width_get",&obj0)) SWIG_fail;
   23065           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23066           0 :   if (!SWIG_IsOK(res1)) {
   23067           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_width_get" "', argument " "1"" of type '" "legendObj *""'"); 
   23068             :   }
   23069           0 :   arg1 = (legendObj *)(argp1);
   23070           0 :   result = (int) ((arg1)->width);
   23071             :   resultobj = SWIG_From_int((int)(result));
   23072           0 :   return resultobj;
   23073           0 : fail:
   23074             :   return NULL;
   23075             : }
   23076             : 
   23077             : 
   23078           0 : SWIGINTERN PyObject *_wrap_legendObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23079             :   PyObject *resultobj = 0;
   23080             :   legendObj *arg1 = (legendObj *) 0 ;
   23081             :   int arg2 ;
   23082           0 :   void *argp1 = 0 ;
   23083             :   int res1 = 0 ;
   23084             :   int val2 ;
   23085             :   int ecode2 = 0 ;
   23086           0 :   PyObject * obj0 = 0 ;
   23087           0 :   PyObject * obj1 = 0 ;
   23088             :   
   23089           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_position_set",&obj0,&obj1)) SWIG_fail;
   23090           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23091           0 :   if (!SWIG_IsOK(res1)) {
   23092           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_position_set" "', argument " "1"" of type '" "legendObj *""'"); 
   23093             :   }
   23094           0 :   arg1 = (legendObj *)(argp1);
   23095           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   23096           0 :   if (!SWIG_IsOK(ecode2)) {
   23097           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_position_set" "', argument " "2"" of type '" "int""'");
   23098             :   } 
   23099             :   arg2 = (int)(val2);
   23100           0 :   if (arg1) (arg1)->position = arg2;
   23101             :   resultobj = SWIG_Py_Void();
   23102           0 :   return resultobj;
   23103           0 : fail:
   23104             :   return NULL;
   23105             : }
   23106             : 
   23107             : 
   23108           0 : SWIGINTERN PyObject *_wrap_legendObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23109             :   PyObject *resultobj = 0;
   23110             :   legendObj *arg1 = (legendObj *) 0 ;
   23111           0 :   void *argp1 = 0 ;
   23112             :   int res1 = 0 ;
   23113           0 :   PyObject * obj0 = 0 ;
   23114             :   int result;
   23115             :   
   23116           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_position_get",&obj0)) SWIG_fail;
   23117           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23118           0 :   if (!SWIG_IsOK(res1)) {
   23119           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_position_get" "', argument " "1"" of type '" "legendObj *""'"); 
   23120             :   }
   23121           0 :   arg1 = (legendObj *)(argp1);
   23122           0 :   result = (int) ((arg1)->position);
   23123             :   resultobj = SWIG_From_int((int)(result));
   23124           0 :   return resultobj;
   23125           0 : fail:
   23126             :   return NULL;
   23127             : }
   23128             : 
   23129             : 
   23130           0 : SWIGINTERN PyObject *_wrap_legendObj_postlabelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23131             :   PyObject *resultobj = 0;
   23132             :   legendObj *arg1 = (legendObj *) 0 ;
   23133             :   int arg2 ;
   23134           0 :   void *argp1 = 0 ;
   23135             :   int res1 = 0 ;
   23136             :   int val2 ;
   23137             :   int ecode2 = 0 ;
   23138           0 :   PyObject * obj0 = 0 ;
   23139           0 :   PyObject * obj1 = 0 ;
   23140             :   
   23141           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_postlabelcache_set",&obj0,&obj1)) SWIG_fail;
   23142           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23143           0 :   if (!SWIG_IsOK(res1)) {
   23144           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_postlabelcache_set" "', argument " "1"" of type '" "legendObj *""'"); 
   23145             :   }
   23146           0 :   arg1 = (legendObj *)(argp1);
   23147           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   23148           0 :   if (!SWIG_IsOK(ecode2)) {
   23149           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_postlabelcache_set" "', argument " "2"" of type '" "int""'");
   23150             :   } 
   23151             :   arg2 = (int)(val2);
   23152           0 :   if (arg1) (arg1)->postlabelcache = arg2;
   23153             :   resultobj = SWIG_Py_Void();
   23154           0 :   return resultobj;
   23155           0 : fail:
   23156             :   return NULL;
   23157             : }
   23158             : 
   23159             : 
   23160           0 : SWIGINTERN PyObject *_wrap_legendObj_postlabelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23161             :   PyObject *resultobj = 0;
   23162             :   legendObj *arg1 = (legendObj *) 0 ;
   23163           0 :   void *argp1 = 0 ;
   23164             :   int res1 = 0 ;
   23165           0 :   PyObject * obj0 = 0 ;
   23166             :   int result;
   23167             :   
   23168           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_postlabelcache_get",&obj0)) SWIG_fail;
   23169           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23170           0 :   if (!SWIG_IsOK(res1)) {
   23171           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_postlabelcache_get" "', argument " "1"" of type '" "legendObj *""'"); 
   23172             :   }
   23173           0 :   arg1 = (legendObj *)(argp1);
   23174           0 :   result = (int) ((arg1)->postlabelcache);
   23175             :   resultobj = SWIG_From_int((int)(result));
   23176           0 :   return resultobj;
   23177           0 : fail:
   23178             :   return NULL;
   23179             : }
   23180             : 
   23181             : 
   23182           0 : SWIGINTERN PyObject *_wrap_legendObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23183             :   PyObject *resultobj = 0;
   23184             :   legendObj *arg1 = (legendObj *) 0 ;
   23185             :   char *arg2 = (char *) 0 ;
   23186           0 :   void *argp1 = 0 ;
   23187             :   int res1 = 0 ;
   23188             :   int res2 ;
   23189           0 :   char *buf2 = 0 ;
   23190           0 :   int alloc2 = 0 ;
   23191           0 :   PyObject * obj0 = 0 ;
   23192           0 :   PyObject * obj1 = 0 ;
   23193             :   
   23194           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_template_set",&obj0,&obj1)) SWIG_fail;
   23195           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23196           0 :   if (!SWIG_IsOK(res1)) {
   23197           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_template_set" "', argument " "1"" of type '" "legendObj *""'"); 
   23198             :   }
   23199           0 :   arg1 = (legendObj *)(argp1);
   23200           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   23201           0 :   if (!SWIG_IsOK(res2)) {
   23202           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_template_set" "', argument " "2"" of type '" "char *""'");
   23203             :   }
   23204           0 :   arg2 = (char *)(buf2);
   23205             :   {
   23206           0 :     if (arg1->template) free((char*)arg1->template);
   23207           0 :     if (arg2) {
   23208           0 :       arg1->template = (char *) malloc(strlen(arg2)+1);
   23209             :       strcpy((char*)arg1->template,arg2);
   23210             :     } else {
   23211           0 :       arg1->template = 0;
   23212             :     }
   23213             :   }
   23214             :   resultobj = SWIG_Py_Void();
   23215           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   23216             :   return resultobj;
   23217           0 : fail:
   23218           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   23219             :   return NULL;
   23220             : }
   23221             : 
   23222             : 
   23223           0 : SWIGINTERN PyObject *_wrap_legendObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23224             :   PyObject *resultobj = 0;
   23225             :   legendObj *arg1 = (legendObj *) 0 ;
   23226           0 :   void *argp1 = 0 ;
   23227             :   int res1 = 0 ;
   23228           0 :   PyObject * obj0 = 0 ;
   23229             :   char *result = 0 ;
   23230             :   
   23231           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_template_get",&obj0)) SWIG_fail;
   23232           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23233           0 :   if (!SWIG_IsOK(res1)) {
   23234           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_template_get" "', argument " "1"" of type '" "legendObj *""'"); 
   23235             :   }
   23236           0 :   arg1 = (legendObj *)(argp1);
   23237           0 :   result = (char *) ((arg1)->template);
   23238           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   23239           0 :   return resultobj;
   23240           0 : fail:
   23241             :   return NULL;
   23242             : }
   23243             : 
   23244             : 
   23245           0 : SWIGINTERN PyObject *_wrap_legendObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23246             :   PyObject *resultobj = 0;
   23247             :   legendObj *arg1 = (legendObj *) 0 ;
   23248           0 :   void *argp1 = 0 ;
   23249             :   int res1 = 0 ;
   23250           0 :   PyObject * obj0 = 0 ;
   23251             :   struct mapObj *result = 0 ;
   23252             :   
   23253           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_map_get",&obj0)) SWIG_fail;
   23254           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23255           0 :   if (!SWIG_IsOK(res1)) {
   23256           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_map_get" "', argument " "1"" of type '" "legendObj *""'"); 
   23257             :   }
   23258           0 :   arg1 = (legendObj *)(argp1);
   23259           0 :   result = (struct mapObj *) ((arg1)->map);
   23260           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 |  0 );
   23261           0 :   return resultobj;
   23262           0 : fail:
   23263             :   return NULL;
   23264             : }
   23265             : 
   23266             : 
   23267           0 : SWIGINTERN PyObject *_wrap_legendObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23268             :   PyObject *resultobj = 0;
   23269             :   legendObj *arg1 = (legendObj *) 0 ;
   23270             :   char *arg2 = (char *) 0 ;
   23271           0 :   void *argp1 = 0 ;
   23272             :   int res1 = 0 ;
   23273             :   int res2 ;
   23274           0 :   char *buf2 = 0 ;
   23275           0 :   int alloc2 = 0 ;
   23276           0 :   PyObject * obj0 = 0 ;
   23277           0 :   PyObject * obj1 = 0 ;
   23278             :   int result;
   23279             :   
   23280           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   23281           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23282           0 :   if (!SWIG_IsOK(res1)) {
   23283           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_updateFromString" "', argument " "1"" of type '" "legendObj *""'"); 
   23284             :   }
   23285           0 :   arg1 = (legendObj *)(argp1);
   23286           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   23287           0 :   if (!SWIG_IsOK(res2)) {
   23288           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   23289             :   }
   23290           0 :   arg2 = (char *)(buf2);
   23291             :   {
   23292             :     result = (int)legendObj_updateFromString(arg1,arg2); {
   23293           0 :       errorObj *ms_error = msGetErrorObj();
   23294             :       
   23295           0 :       switch(ms_error->code) {
   23296             :       case MS_NOERR:
   23297             :         break;
   23298           0 :       case MS_NOTFOUND:
   23299           0 :         msResetErrorList();
   23300           0 :         break;
   23301             :       case -1:
   23302             :         break;
   23303           0 :       case MS_IOERR:
   23304           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23305           0 :           _raise_ms_exception();
   23306           0 :           msResetErrorList();
   23307           0 :           return NULL;
   23308             :         }
   23309             :       default:
   23310           0 :         _raise_ms_exception();
   23311           0 :         msResetErrorList();
   23312           0 :         return NULL;
   23313             :       }
   23314             :       
   23315             :     }
   23316             :   }
   23317             :   resultobj = SWIG_From_int((int)(result));
   23318           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   23319             :   return resultobj;
   23320           0 : fail:
   23321           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   23322             :   return NULL;
   23323             : }
   23324             : 
   23325             : 
   23326           0 : SWIGINTERN PyObject *_wrap_legendObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23327             :   PyObject *resultobj = 0;
   23328             :   legendObj *arg1 = (legendObj *) 0 ;
   23329           0 :   void *argp1 = 0 ;
   23330             :   int res1 = 0 ;
   23331           0 :   PyObject * obj0 = 0 ;
   23332             :   char *result = 0 ;
   23333             :   
   23334           0 :   if (!PyArg_ParseTuple(args,(char *)"O:legendObj_convertToString",&obj0)) SWIG_fail;
   23335           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 |  0 );
   23336           0 :   if (!SWIG_IsOK(res1)) {
   23337           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_convertToString" "', argument " "1"" of type '" "legendObj *""'"); 
   23338             :   }
   23339           0 :   arg1 = (legendObj *)(argp1);
   23340             :   {
   23341             :     result = (char *)legendObj_convertToString(arg1); {
   23342           0 :       errorObj *ms_error = msGetErrorObj();
   23343             :       
   23344           0 :       switch(ms_error->code) {
   23345             :       case MS_NOERR:
   23346             :         break;
   23347           0 :       case MS_NOTFOUND:
   23348           0 :         msResetErrorList();
   23349           0 :         break;
   23350             :       case -1:
   23351             :         break;
   23352           0 :       case MS_IOERR:
   23353           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23354           0 :           _raise_ms_exception();
   23355           0 :           msResetErrorList();
   23356           0 :           return NULL;
   23357             :         }
   23358             :       default:
   23359           0 :         _raise_ms_exception();
   23360           0 :         msResetErrorList();
   23361           0 :         return NULL;
   23362             :       }
   23363             :       
   23364             :     }
   23365             :   }
   23366           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   23367           0 :   free((char*)result);
   23368           0 :   return resultobj;
   23369           0 : fail:
   23370             :   return NULL;
   23371             : }
   23372             : 
   23373             : 
   23374           0 : SWIGINTERN PyObject *_wrap_new_legendObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23375             :   PyObject *resultobj = 0;
   23376             :   legendObj *result = 0 ;
   23377             :   
   23378           0 :   if (!PyArg_ParseTuple(args,(char *)":new_legendObj")) SWIG_fail;
   23379             :   {
   23380           0 :     result = (legendObj *)calloc(1, sizeof(legendObj)); {
   23381           0 :       errorObj *ms_error = msGetErrorObj();
   23382             :       
   23383           0 :       switch(ms_error->code) {
   23384             :       case MS_NOERR:
   23385             :         break;
   23386           0 :       case MS_NOTFOUND:
   23387           0 :         msResetErrorList();
   23388           0 :         break;
   23389             :       case -1:
   23390             :         break;
   23391           0 :       case MS_IOERR:
   23392           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23393           0 :           _raise_ms_exception();
   23394           0 :           msResetErrorList();
   23395           0 :           return NULL;
   23396             :         }
   23397             :       default:
   23398           0 :         _raise_ms_exception();
   23399           0 :         msResetErrorList();
   23400           0 :         return NULL;
   23401             :       }
   23402             :       
   23403             :     }
   23404             :   }
   23405           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_legendObj, SWIG_POINTER_NEW |  0 );
   23406           0 :   return resultobj;
   23407           0 : fail:
   23408             :   return NULL;
   23409             : }
   23410             : 
   23411             : 
   23412           0 : SWIGINTERN PyObject *_wrap_delete_legendObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23413             :   PyObject *resultobj = 0;
   23414             :   legendObj *arg1 = (legendObj *) 0 ;
   23415           0 :   void *argp1 = 0 ;
   23416             :   int res1 = 0 ;
   23417           0 :   PyObject * obj0 = 0 ;
   23418             :   
   23419           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_legendObj",&obj0)) SWIG_fail;
   23420           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, SWIG_POINTER_DISOWN |  0 );
   23421           0 :   if (!SWIG_IsOK(res1)) {
   23422           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_legendObj" "', argument " "1"" of type '" "legendObj *""'"); 
   23423             :   }
   23424           0 :   arg1 = (legendObj *)(argp1);
   23425             :   {
   23426           0 :     free((char *) arg1); {
   23427           0 :       errorObj *ms_error = msGetErrorObj();
   23428             :       
   23429           0 :       switch(ms_error->code) {
   23430             :       case MS_NOERR:
   23431             :         break;
   23432           0 :       case MS_NOTFOUND:
   23433           0 :         msResetErrorList();
   23434           0 :         break;
   23435             :       case -1:
   23436             :         break;
   23437           0 :       case MS_IOERR:
   23438           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23439           0 :           _raise_ms_exception();
   23440           0 :           msResetErrorList();
   23441           0 :           return NULL;
   23442             :         }
   23443             :       default:
   23444           0 :         _raise_ms_exception();
   23445           0 :         msResetErrorList();
   23446           0 :         return NULL;
   23447             :       }
   23448             :       
   23449             :     }
   23450             :   }
   23451             :   resultobj = SWIG_Py_Void();
   23452           0 :   return resultobj;
   23453           0 : fail:
   23454             :   return NULL;
   23455             : }
   23456             : 
   23457             : 
   23458           1 : SWIGINTERN PyObject *legendObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23459             :   PyObject *obj;
   23460           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   23461           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_legendObj, SWIG_NewClientData(obj));
   23462           1 :   return SWIG_Py_Void();
   23463             : }
   23464             : 
   23465           1 : SWIGINTERN PyObject *_wrap_imageObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23466             :   PyObject *resultobj = 0;
   23467             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23468           1 :   void *argp1 = 0 ;
   23469             :   int res1 = 0 ;
   23470           1 :   PyObject * obj0 = 0 ;
   23471             :   int result;
   23472             :   
   23473           1 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_width_get",&obj0)) SWIG_fail;
   23474           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23475           1 :   if (!SWIG_IsOK(res1)) {
   23476           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_width_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23477             :   }
   23478           1 :   arg1 = (struct imageObj *)(argp1);
   23479           1 :   result = (int) ((arg1)->width);
   23480             :   resultobj = SWIG_From_int((int)(result));
   23481           1 :   return resultobj;
   23482           0 : fail:
   23483             :   return NULL;
   23484             : }
   23485             : 
   23486             : 
   23487           1 : SWIGINTERN PyObject *_wrap_imageObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23488             :   PyObject *resultobj = 0;
   23489             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23490           1 :   void *argp1 = 0 ;
   23491             :   int res1 = 0 ;
   23492           1 :   PyObject * obj0 = 0 ;
   23493             :   int result;
   23494             :   
   23495           1 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_height_get",&obj0)) SWIG_fail;
   23496           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23497           1 :   if (!SWIG_IsOK(res1)) {
   23498           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_height_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23499             :   }
   23500           1 :   arg1 = (struct imageObj *)(argp1);
   23501           1 :   result = (int) ((arg1)->height);
   23502             :   resultobj = SWIG_From_int((int)(result));
   23503           1 :   return resultobj;
   23504           0 : fail:
   23505             :   return NULL;
   23506             : }
   23507             : 
   23508             : 
   23509           0 : SWIGINTERN PyObject *_wrap_imageObj_resolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23510             :   PyObject *resultobj = 0;
   23511             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23512           0 :   void *argp1 = 0 ;
   23513             :   int res1 = 0 ;
   23514           0 :   PyObject * obj0 = 0 ;
   23515             :   double result;
   23516             :   
   23517           0 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_resolution_get",&obj0)) SWIG_fail;
   23518           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23519           0 :   if (!SWIG_IsOK(res1)) {
   23520           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_resolution_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23521             :   }
   23522           0 :   arg1 = (struct imageObj *)(argp1);
   23523           0 :   result = (double) ((arg1)->resolution);
   23524           0 :   resultobj = SWIG_From_double((double)(result));
   23525           0 :   return resultobj;
   23526           0 : fail:
   23527             :   return NULL;
   23528             : }
   23529             : 
   23530             : 
   23531           0 : SWIGINTERN PyObject *_wrap_imageObj_resolutionfactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23532             :   PyObject *resultobj = 0;
   23533             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23534           0 :   void *argp1 = 0 ;
   23535             :   int res1 = 0 ;
   23536           0 :   PyObject * obj0 = 0 ;
   23537             :   double result;
   23538             :   
   23539           0 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_resolutionfactor_get",&obj0)) SWIG_fail;
   23540           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23541           0 :   if (!SWIG_IsOK(res1)) {
   23542           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_resolutionfactor_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23543             :   }
   23544           0 :   arg1 = (struct imageObj *)(argp1);
   23545           0 :   result = (double) ((arg1)->resolutionfactor);
   23546           0 :   resultobj = SWIG_From_double((double)(result));
   23547           0 :   return resultobj;
   23548           0 : fail:
   23549             :   return NULL;
   23550             : }
   23551             : 
   23552             : 
   23553           0 : SWIGINTERN PyObject *_wrap_imageObj_imagepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23554             :   PyObject *resultobj = 0;
   23555             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23556           0 :   void *argp1 = 0 ;
   23557             :   int res1 = 0 ;
   23558           0 :   PyObject * obj0 = 0 ;
   23559             :   char *result = 0 ;
   23560             :   
   23561           0 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_imagepath_get",&obj0)) SWIG_fail;
   23562           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23563           0 :   if (!SWIG_IsOK(res1)) {
   23564           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_imagepath_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23565             :   }
   23566           0 :   arg1 = (struct imageObj *)(argp1);
   23567           0 :   result = (char *) ((arg1)->imagepath);
   23568           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   23569           0 :   return resultobj;
   23570           0 : fail:
   23571             :   return NULL;
   23572             : }
   23573             : 
   23574             : 
   23575           0 : SWIGINTERN PyObject *_wrap_imageObj_imageurl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23576             :   PyObject *resultobj = 0;
   23577             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23578           0 :   void *argp1 = 0 ;
   23579             :   int res1 = 0 ;
   23580           0 :   PyObject * obj0 = 0 ;
   23581             :   char *result = 0 ;
   23582             :   
   23583           0 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_imageurl_get",&obj0)) SWIG_fail;
   23584           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23585           0 :   if (!SWIG_IsOK(res1)) {
   23586           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_imageurl_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23587             :   }
   23588           0 :   arg1 = (struct imageObj *)(argp1);
   23589           0 :   result = (char *) ((arg1)->imageurl);
   23590           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   23591           0 :   return resultobj;
   23592           0 : fail:
   23593             :   return NULL;
   23594             : }
   23595             : 
   23596             : 
   23597           1 : SWIGINTERN PyObject *_wrap_imageObj_format_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23598             :   PyObject *resultobj = 0;
   23599             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23600           1 :   void *argp1 = 0 ;
   23601             :   int res1 = 0 ;
   23602           1 :   PyObject * obj0 = 0 ;
   23603             :   outputFormatObj *result = 0 ;
   23604             :   
   23605           1 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_format_get",&obj0)) SWIG_fail;
   23606           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23607           1 :   if (!SWIG_IsOK(res1)) {
   23608           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_format_get" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23609             :   }
   23610           1 :   arg1 = (struct imageObj *)(argp1);
   23611           1 :   result = (outputFormatObj *) ((arg1)->format);
   23612           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, 0 |  0 );
   23613           1 :   return resultobj;
   23614           0 : fail:
   23615             :   return NULL;
   23616             : }
   23617             : 
   23618             : 
   23619           1 : SWIGINTERN PyObject *_wrap_new_imageObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23620             :   PyObject *resultobj = 0;
   23621             :   int arg1 ;
   23622             :   int arg2 ;
   23623             :   outputFormatObj *arg3 = (outputFormatObj *) NULL ;
   23624             :   char *arg4 = (char *) NULL ;
   23625             :   double arg5 = (double) MS_DEFAULT_RESOLUTION ;
   23626             :   double arg6 = (double) MS_DEFAULT_RESOLUTION ;
   23627             :   int val1 ;
   23628             :   int ecode1 = 0 ;
   23629             :   int val2 ;
   23630             :   int ecode2 = 0 ;
   23631           1 :   void *argp3 = 0 ;
   23632             :   int res3 = 0 ;
   23633             :   int res4 ;
   23634           1 :   char *buf4 = 0 ;
   23635           1 :   int alloc4 = 0 ;
   23636             :   double val5 ;
   23637             :   int ecode5 = 0 ;
   23638             :   double val6 ;
   23639             :   int ecode6 = 0 ;
   23640           1 :   PyObject * obj0 = 0 ;
   23641           1 :   PyObject * obj1 = 0 ;
   23642           1 :   PyObject * obj2 = 0 ;
   23643           1 :   PyObject * obj3 = 0 ;
   23644           1 :   PyObject * obj4 = 0 ;
   23645           1 :   PyObject * obj5 = 0 ;
   23646             :   struct imageObj *result = 0 ;
   23647             :   
   23648           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:new_imageObj",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   23649           1 :   ecode1 = SWIG_AsVal_int(obj0, &val1);
   23650           1 :   if (!SWIG_IsOK(ecode1)) {
   23651           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_imageObj" "', argument " "1"" of type '" "int""'");
   23652             :   } 
   23653             :   arg1 = (int)(val1);
   23654           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   23655           1 :   if (!SWIG_IsOK(ecode2)) {
   23656           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_imageObj" "', argument " "2"" of type '" "int""'");
   23657             :   } 
   23658             :   arg2 = (int)(val2);
   23659           1 :   if (obj2) {
   23660           1 :     res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_outputFormatObj, 0 |  0 );
   23661           1 :     if (!SWIG_IsOK(res3)) {
   23662           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_imageObj" "', argument " "3"" of type '" "outputFormatObj *""'"); 
   23663             :     }
   23664           1 :     arg3 = (outputFormatObj *)(argp3);
   23665             :   }
   23666           1 :   if (obj3) {
   23667           0 :     res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
   23668           0 :     if (!SWIG_IsOK(res4)) {
   23669           0 :       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_imageObj" "', argument " "4"" of type '" "char const *""'");
   23670             :     }
   23671           0 :     arg4 = (char *)(buf4);
   23672             :   }
   23673           1 :   if (obj4) {
   23674           0 :     ecode5 = SWIG_AsVal_double(obj4, &val5);
   23675           0 :     if (!SWIG_IsOK(ecode5)) {
   23676           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_imageObj" "', argument " "5"" of type '" "double""'");
   23677             :     } 
   23678           0 :     arg5 = (double)(val5);
   23679             :   }
   23680           1 :   if (obj5) {
   23681           0 :     ecode6 = SWIG_AsVal_double(obj5, &val6);
   23682           0 :     if (!SWIG_IsOK(ecode6)) {
   23683           0 :       SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_imageObj" "', argument " "6"" of type '" "double""'");
   23684             :     } 
   23685           0 :     arg6 = (double)(val6);
   23686             :   }
   23687             :   {
   23688           1 :     result = (struct imageObj *)new_imageObj(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); {
   23689           1 :       errorObj *ms_error = msGetErrorObj();
   23690             :       
   23691           1 :       switch(ms_error->code) {
   23692             :       case MS_NOERR:
   23693             :         break;
   23694           0 :       case MS_NOTFOUND:
   23695           0 :         msResetErrorList();
   23696           0 :         break;
   23697             :       case -1:
   23698             :         break;
   23699           0 :       case MS_IOERR:
   23700           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23701           0 :           _raise_ms_exception();
   23702           0 :           msResetErrorList();
   23703           0 :           return NULL;
   23704             :         }
   23705             :       default:
   23706           0 :         _raise_ms_exception();
   23707           0 :         msResetErrorList();
   23708           0 :         return NULL;
   23709             :       }
   23710             :       
   23711             :     }
   23712             :   }
   23713           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_NEW |  0 );
   23714           1 :   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
   23715             :   return resultobj;
   23716           0 : fail:
   23717           0 :   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
   23718             :   return NULL;
   23719             : }
   23720             : 
   23721             : 
   23722           1 : SWIGINTERN PyObject *_wrap_delete_imageObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23723             :   PyObject *resultobj = 0;
   23724             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23725           1 :   void *argp1 = 0 ;
   23726             :   int res1 = 0 ;
   23727           1 :   PyObject * obj0 = 0 ;
   23728             :   
   23729           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_imageObj",&obj0)) SWIG_fail;
   23730           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, SWIG_POINTER_DISOWN |  0 );
   23731           1 :   if (!SWIG_IsOK(res1)) {
   23732           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_imageObj" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23733             :   }
   23734           1 :   arg1 = (struct imageObj *)(argp1);
   23735             :   {
   23736             :     delete_imageObj(arg1); {
   23737           1 :       errorObj *ms_error = msGetErrorObj();
   23738             :       
   23739           1 :       switch(ms_error->code) {
   23740             :       case MS_NOERR:
   23741             :         break;
   23742           0 :       case MS_NOTFOUND:
   23743           0 :         msResetErrorList();
   23744           0 :         break;
   23745             :       case -1:
   23746             :         break;
   23747           0 :       case MS_IOERR:
   23748           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23749           0 :           _raise_ms_exception();
   23750           0 :           msResetErrorList();
   23751           0 :           return NULL;
   23752             :         }
   23753             :       default:
   23754           0 :         _raise_ms_exception();
   23755           0 :         msResetErrorList();
   23756           0 :         return NULL;
   23757             :       }
   23758             :       
   23759             :     }
   23760             :   }
   23761             :   resultobj = SWIG_Py_Void();
   23762           1 :   return resultobj;
   23763           0 : fail:
   23764             :   return NULL;
   23765             : }
   23766             : 
   23767             : 
   23768           1 : SWIGINTERN PyObject *_wrap_imageObj_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23769             :   PyObject *resultobj = 0;
   23770             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23771             :   char *arg2 = (char *) 0 ;
   23772             :   mapObj *arg3 = (mapObj *) NULL ;
   23773           1 :   void *argp1 = 0 ;
   23774             :   int res1 = 0 ;
   23775             :   int res2 ;
   23776           1 :   char *buf2 = 0 ;
   23777           1 :   int alloc2 = 0 ;
   23778           1 :   void *argp3 = 0 ;
   23779             :   int res3 = 0 ;
   23780           1 :   PyObject * obj0 = 0 ;
   23781           1 :   PyObject * obj1 = 0 ;
   23782           1 :   PyObject * obj2 = 0 ;
   23783             :   
   23784           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:imageObj_save",&obj0,&obj1,&obj2)) SWIG_fail;
   23785           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23786           1 :   if (!SWIG_IsOK(res1)) {
   23787           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_save" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23788             :   }
   23789           1 :   arg1 = (struct imageObj *)(argp1);
   23790           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   23791           1 :   if (!SWIG_IsOK(res2)) {
   23792           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "imageObj_save" "', argument " "2"" of type '" "char *""'");
   23793             :   }
   23794           1 :   arg2 = (char *)(buf2);
   23795           1 :   if (obj2) {
   23796           1 :     res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mapObj, 0 |  0 );
   23797           1 :     if (!SWIG_IsOK(res3)) {
   23798           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "imageObj_save" "', argument " "3"" of type '" "mapObj *""'"); 
   23799             :     }
   23800           1 :     arg3 = (mapObj *)(argp3);
   23801             :   }
   23802             :   {
   23803             :     imageObj_save(arg1,arg2,arg3); {
   23804           1 :       errorObj *ms_error = msGetErrorObj();
   23805             :       
   23806           1 :       switch(ms_error->code) {
   23807             :       case MS_NOERR:
   23808             :         break;
   23809           0 :       case MS_NOTFOUND:
   23810           0 :         msResetErrorList();
   23811           0 :         break;
   23812             :       case -1:
   23813             :         break;
   23814           0 :       case MS_IOERR:
   23815           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23816           0 :           _raise_ms_exception();
   23817           0 :           msResetErrorList();
   23818           0 :           return NULL;
   23819             :         }
   23820             :       default:
   23821           0 :         _raise_ms_exception();
   23822           0 :         msResetErrorList();
   23823           0 :         return NULL;
   23824             :       }
   23825             :       
   23826             :     }
   23827             :   }
   23828             :   resultobj = SWIG_Py_Void();
   23829           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   23830             :   return resultobj;
   23831           0 : fail:
   23832           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   23833             :   return NULL;
   23834             : }
   23835             : 
   23836             : 
   23837           1 : SWIGINTERN PyObject *_wrap_imageObj_getBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23838             :   PyObject *resultobj = 0;
   23839             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23840           1 :   void *argp1 = 0 ;
   23841             :   int res1 = 0 ;
   23842           1 :   PyObject * obj0 = 0 ;
   23843             :   gdBuffer result;
   23844             :   
   23845           1 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_getBytes",&obj0)) SWIG_fail;
   23846           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23847           1 :   if (!SWIG_IsOK(res1)) {
   23848           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_getBytes" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23849             :   }
   23850           1 :   arg1 = (struct imageObj *)(argp1);
   23851             :   {
   23852           1 :     result = imageObj_getBytes(arg1); {
   23853           1 :       errorObj *ms_error = msGetErrorObj();
   23854             :       
   23855           1 :       switch(ms_error->code) {
   23856             :       case MS_NOERR:
   23857             :         break;
   23858           0 :       case MS_NOTFOUND:
   23859           0 :         msResetErrorList();
   23860           0 :         break;
   23861             :       case -1:
   23862             :         break;
   23863           0 :       case MS_IOERR:
   23864           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23865           0 :           _raise_ms_exception();
   23866           0 :           msResetErrorList();
   23867           0 :           return NULL;
   23868             :         }
   23869             :       default:
   23870           0 :         _raise_ms_exception();
   23871           0 :         msResetErrorList();
   23872           0 :         return NULL;
   23873             :       }
   23874             :       
   23875             :     }
   23876             :   }
   23877             :   {
   23878           1 :     resultobj = PyBytes_FromStringAndSize((const char*)(&result)->data, (&result)->size);
   23879           1 :     if( (&result)->owns_data )
   23880           1 :     msFree((&result)->data);
   23881             :   }
   23882             :   return resultobj;
   23883           0 : fail:
   23884             :   return NULL;
   23885             : }
   23886             : 
   23887             : 
   23888           0 : SWIGINTERN PyObject *_wrap_imageObj_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23889             :   PyObject *resultobj = 0;
   23890             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23891           0 :   void *argp1 = 0 ;
   23892             :   int res1 = 0 ;
   23893           0 :   PyObject * obj0 = 0 ;
   23894             :   int result;
   23895             :   
   23896           0 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_getSize",&obj0)) SWIG_fail;
   23897           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23898           0 :   if (!SWIG_IsOK(res1)) {
   23899           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_getSize" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23900             :   }
   23901           0 :   arg1 = (struct imageObj *)(argp1);
   23902             :   {
   23903           0 :     result = (int)imageObj_getSize(arg1); {
   23904           0 :       errorObj *ms_error = msGetErrorObj();
   23905             :       
   23906           0 :       switch(ms_error->code) {
   23907             :       case MS_NOERR:
   23908             :         break;
   23909           0 :       case MS_NOTFOUND:
   23910           0 :         msResetErrorList();
   23911           0 :         break;
   23912             :       case -1:
   23913             :         break;
   23914           0 :       case MS_IOERR:
   23915           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23916           0 :           _raise_ms_exception();
   23917           0 :           msResetErrorList();
   23918           0 :           return NULL;
   23919             :         }
   23920             :       default:
   23921           0 :         _raise_ms_exception();
   23922           0 :         msResetErrorList();
   23923           0 :         return NULL;
   23924             :       }
   23925             :       
   23926             :     }
   23927             :   }
   23928             :   resultobj = SWIG_From_int((int)(result));
   23929           0 :   return resultobj;
   23930           0 : fail:
   23931             :   return NULL;
   23932             : }
   23933             : 
   23934             : 
   23935           1 : SWIGINTERN PyObject *_wrap_imageObj_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23936             :   PyObject *resultobj = 0;
   23937             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23938             :   PyObject *arg2 = (PyObject *) Py_None ;
   23939           1 :   void *argp1 = 0 ;
   23940             :   int res1 = 0 ;
   23941           1 :   PyObject * obj0 = 0 ;
   23942           1 :   PyObject * obj1 = 0 ;
   23943             :   int result;
   23944             :   
   23945           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:imageObj_write",&obj0,&obj1)) SWIG_fail;
   23946           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23947           1 :   if (!SWIG_IsOK(res1)) {
   23948           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_write" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23949             :   }
   23950           1 :   arg1 = (struct imageObj *)(argp1);
   23951           1 :   if (obj1) {
   23952             :     arg2 = obj1;
   23953             :   }
   23954             :   {
   23955           1 :     result = (int)imageObj_write(arg1,arg2); {
   23956           1 :       errorObj *ms_error = msGetErrorObj();
   23957             :       
   23958           1 :       switch(ms_error->code) {
   23959             :       case MS_NOERR:
   23960             :         break;
   23961           0 :       case MS_NOTFOUND:
   23962           0 :         msResetErrorList();
   23963           0 :         break;
   23964             :       case -1:
   23965             :         break;
   23966           0 :       case MS_IOERR:
   23967           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   23968           0 :           _raise_ms_exception();
   23969           0 :           msResetErrorList();
   23970           0 :           return NULL;
   23971             :         }
   23972             :       default:
   23973           0 :         _raise_ms_exception();
   23974           0 :         msResetErrorList();
   23975           0 :         return NULL;
   23976             :       }
   23977             :       
   23978             :     }
   23979             :   }
   23980             :   resultobj = SWIG_From_int((int)(result));
   23981           1 :   return resultobj;
   23982           0 : fail:
   23983             :   return NULL;
   23984             : }
   23985             : 
   23986             : 
   23987           1 : SWIGINTERN PyObject *_wrap_imageObj_saveToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   23988             :   PyObject *resultobj = 0;
   23989             :   struct imageObj *arg1 = (struct imageObj *) 0 ;
   23990           1 :   void *argp1 = 0 ;
   23991             :   int res1 = 0 ;
   23992           1 :   PyObject * obj0 = 0 ;
   23993             :   PyObject *result = 0 ;
   23994             :   
   23995           1 :   if (!PyArg_ParseTuple(args,(char *)"O:imageObj_saveToString",&obj0)) SWIG_fail;
   23996           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   23997           1 :   if (!SWIG_IsOK(res1)) {
   23998           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_saveToString" "', argument " "1"" of type '" "struct imageObj *""'"); 
   23999             :   }
   24000           1 :   arg1 = (struct imageObj *)(argp1);
   24001             :   {
   24002           1 :     result = (PyObject *)imageObj_saveToString(arg1); {
   24003           1 :       errorObj *ms_error = msGetErrorObj();
   24004             :       
   24005           1 :       switch(ms_error->code) {
   24006             :       case MS_NOERR:
   24007             :         break;
   24008           0 :       case MS_NOTFOUND:
   24009           0 :         msResetErrorList();
   24010           0 :         break;
   24011             :       case -1:
   24012             :         break;
   24013           0 :       case MS_IOERR:
   24014           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   24015           0 :           _raise_ms_exception();
   24016           0 :           msResetErrorList();
   24017           0 :           return NULL;
   24018             :         }
   24019             :       default:
   24020           0 :         _raise_ms_exception();
   24021           0 :         msResetErrorList();
   24022           0 :         return NULL;
   24023             :       }
   24024             :       
   24025             :     }
   24026             :   }
   24027             :   resultobj = result;
   24028             :   return resultobj;
   24029           0 : fail:
   24030             :   return NULL;
   24031             : }
   24032             : 
   24033             : 
   24034           1 : SWIGINTERN PyObject *imageObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24035             :   PyObject *obj;
   24036           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   24037           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_imageObj, SWIG_NewClientData(obj));
   24038           1 :   return SWIG_Py_Void();
   24039             : }
   24040             : 
   24041           0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_minscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24042             :   PyObject *resultobj = 0;
   24043             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24044             :   double arg2 ;
   24045           0 :   void *argp1 = 0 ;
   24046             :   int res1 = 0 ;
   24047             :   double val2 ;
   24048             :   int ecode2 = 0 ;
   24049           0 :   PyObject * obj0 = 0 ;
   24050           0 :   PyObject * obj1 = 0 ;
   24051             :   
   24052           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenEntryObj_minscale_set",&obj0,&obj1)) SWIG_fail;
   24053           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24054           0 :   if (!SWIG_IsOK(res1)) {
   24055           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_minscale_set" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24056             :   }
   24057           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24058           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   24059           0 :   if (!SWIG_IsOK(ecode2)) {
   24060           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scaleTokenEntryObj_minscale_set" "', argument " "2"" of type '" "double""'");
   24061             :   } 
   24062           0 :   arg2 = (double)(val2);
   24063           0 :   if (arg1) (arg1)->minscale = arg2;
   24064             :   resultobj = SWIG_Py_Void();
   24065           0 :   return resultobj;
   24066           0 : fail:
   24067             :   return NULL;
   24068             : }
   24069             : 
   24070             : 
   24071           0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_minscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24072             :   PyObject *resultobj = 0;
   24073             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24074           0 :   void *argp1 = 0 ;
   24075             :   int res1 = 0 ;
   24076           0 :   PyObject * obj0 = 0 ;
   24077             :   double result;
   24078             :   
   24079           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenEntryObj_minscale_get",&obj0)) SWIG_fail;
   24080           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24081           0 :   if (!SWIG_IsOK(res1)) {
   24082           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_minscale_get" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24083             :   }
   24084           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24085           0 :   result = (double) ((arg1)->minscale);
   24086           0 :   resultobj = SWIG_From_double((double)(result));
   24087           0 :   return resultobj;
   24088           0 : fail:
   24089             :   return NULL;
   24090             : }
   24091             : 
   24092             : 
   24093           0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_maxscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24094             :   PyObject *resultobj = 0;
   24095             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24096             :   double arg2 ;
   24097           0 :   void *argp1 = 0 ;
   24098             :   int res1 = 0 ;
   24099             :   double val2 ;
   24100             :   int ecode2 = 0 ;
   24101           0 :   PyObject * obj0 = 0 ;
   24102           0 :   PyObject * obj1 = 0 ;
   24103             :   
   24104           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenEntryObj_maxscale_set",&obj0,&obj1)) SWIG_fail;
   24105           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24106           0 :   if (!SWIG_IsOK(res1)) {
   24107           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_maxscale_set" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24108             :   }
   24109           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24110           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   24111           0 :   if (!SWIG_IsOK(ecode2)) {
   24112           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scaleTokenEntryObj_maxscale_set" "', argument " "2"" of type '" "double""'");
   24113             :   } 
   24114           0 :   arg2 = (double)(val2);
   24115           0 :   if (arg1) (arg1)->maxscale = arg2;
   24116             :   resultobj = SWIG_Py_Void();
   24117           0 :   return resultobj;
   24118           0 : fail:
   24119             :   return NULL;
   24120             : }
   24121             : 
   24122             : 
   24123           0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_maxscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24124             :   PyObject *resultobj = 0;
   24125             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24126           0 :   void *argp1 = 0 ;
   24127             :   int res1 = 0 ;
   24128           0 :   PyObject * obj0 = 0 ;
   24129             :   double result;
   24130             :   
   24131           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenEntryObj_maxscale_get",&obj0)) SWIG_fail;
   24132           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24133           0 :   if (!SWIG_IsOK(res1)) {
   24134           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_maxscale_get" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24135             :   }
   24136           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24137           0 :   result = (double) ((arg1)->maxscale);
   24138           0 :   resultobj = SWIG_From_double((double)(result));
   24139           0 :   return resultobj;
   24140           0 : fail:
   24141             :   return NULL;
   24142             : }
   24143             : 
   24144             : 
   24145           0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24146             :   PyObject *resultobj = 0;
   24147             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24148             :   char *arg2 = (char *) 0 ;
   24149           0 :   void *argp1 = 0 ;
   24150             :   int res1 = 0 ;
   24151             :   int res2 ;
   24152           0 :   char *buf2 = 0 ;
   24153           0 :   int alloc2 = 0 ;
   24154           0 :   PyObject * obj0 = 0 ;
   24155           0 :   PyObject * obj1 = 0 ;
   24156             :   
   24157           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenEntryObj_value_set",&obj0,&obj1)) SWIG_fail;
   24158           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24159           0 :   if (!SWIG_IsOK(res1)) {
   24160           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_value_set" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24161             :   }
   24162           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24163           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24164           0 :   if (!SWIG_IsOK(res2)) {
   24165           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scaleTokenEntryObj_value_set" "', argument " "2"" of type '" "char *""'");
   24166             :   }
   24167           0 :   arg2 = (char *)(buf2);
   24168             :   {
   24169           0 :     if (arg1->value) free((char*)arg1->value);
   24170           0 :     if (arg2) {
   24171           0 :       arg1->value = (char *) malloc(strlen(arg2)+1);
   24172             :       strcpy((char*)arg1->value,arg2);
   24173             :     } else {
   24174           0 :       arg1->value = 0;
   24175             :     }
   24176             :   }
   24177             :   resultobj = SWIG_Py_Void();
   24178           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24179             :   return resultobj;
   24180           0 : fail:
   24181           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24182             :   return NULL;
   24183             : }
   24184             : 
   24185             : 
   24186           0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24187             :   PyObject *resultobj = 0;
   24188             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24189           0 :   void *argp1 = 0 ;
   24190             :   int res1 = 0 ;
   24191           0 :   PyObject * obj0 = 0 ;
   24192             :   char *result = 0 ;
   24193             :   
   24194           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenEntryObj_value_get",&obj0)) SWIG_fail;
   24195           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24196           0 :   if (!SWIG_IsOK(res1)) {
   24197           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_value_get" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24198             :   }
   24199           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24200           0 :   result = (char *) ((arg1)->value);
   24201           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24202           0 :   return resultobj;
   24203           0 : fail:
   24204             :   return NULL;
   24205             : }
   24206             : 
   24207             : 
   24208           0 : SWIGINTERN PyObject *_wrap_new_scaleTokenEntryObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24209             :   PyObject *resultobj = 0;
   24210             :   scaleTokenEntryObj *result = 0 ;
   24211             :   
   24212           0 :   if (!PyArg_ParseTuple(args,(char *)":new_scaleTokenEntryObj")) SWIG_fail;
   24213             :   {
   24214           0 :     result = (scaleTokenEntryObj *)calloc(1, sizeof(scaleTokenEntryObj)); {
   24215           0 :       errorObj *ms_error = msGetErrorObj();
   24216             :       
   24217           0 :       switch(ms_error->code) {
   24218             :       case MS_NOERR:
   24219             :         break;
   24220           0 :       case MS_NOTFOUND:
   24221           0 :         msResetErrorList();
   24222           0 :         break;
   24223             :       case -1:
   24224             :         break;
   24225           0 :       case MS_IOERR:
   24226           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   24227           0 :           _raise_ms_exception();
   24228           0 :           msResetErrorList();
   24229           0 :           return NULL;
   24230             :         }
   24231             :       default:
   24232           0 :         _raise_ms_exception();
   24233           0 :         msResetErrorList();
   24234           0 :         return NULL;
   24235             :       }
   24236             :       
   24237             :     }
   24238             :   }
   24239           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scaleTokenEntryObj, SWIG_POINTER_NEW |  0 );
   24240           0 :   return resultobj;
   24241           0 : fail:
   24242             :   return NULL;
   24243             : }
   24244             : 
   24245             : 
   24246           0 : SWIGINTERN PyObject *_wrap_delete_scaleTokenEntryObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24247             :   PyObject *resultobj = 0;
   24248             :   scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
   24249           0 :   void *argp1 = 0 ;
   24250             :   int res1 = 0 ;
   24251           0 :   PyObject * obj0 = 0 ;
   24252             :   
   24253           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_scaleTokenEntryObj",&obj0)) SWIG_fail;
   24254           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, SWIG_POINTER_DISOWN |  0 );
   24255           0 :   if (!SWIG_IsOK(res1)) {
   24256           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scaleTokenEntryObj" "', argument " "1"" of type '" "scaleTokenEntryObj *""'"); 
   24257             :   }
   24258           0 :   arg1 = (scaleTokenEntryObj *)(argp1);
   24259             :   {
   24260           0 :     free((char *) arg1); {
   24261           0 :       errorObj *ms_error = msGetErrorObj();
   24262             :       
   24263           0 :       switch(ms_error->code) {
   24264             :       case MS_NOERR:
   24265             :         break;
   24266           0 :       case MS_NOTFOUND:
   24267           0 :         msResetErrorList();
   24268           0 :         break;
   24269             :       case -1:
   24270             :         break;
   24271           0 :       case MS_IOERR:
   24272           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   24273           0 :           _raise_ms_exception();
   24274           0 :           msResetErrorList();
   24275           0 :           return NULL;
   24276             :         }
   24277             :       default:
   24278           0 :         _raise_ms_exception();
   24279           0 :         msResetErrorList();
   24280           0 :         return NULL;
   24281             :       }
   24282             :       
   24283             :     }
   24284             :   }
   24285             :   resultobj = SWIG_Py_Void();
   24286           0 :   return resultobj;
   24287           0 : fail:
   24288             :   return NULL;
   24289             : }
   24290             : 
   24291             : 
   24292           1 : SWIGINTERN PyObject *scaleTokenEntryObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24293             :   PyObject *obj;
   24294           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   24295           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_scaleTokenEntryObj, SWIG_NewClientData(obj));
   24296           1 :   return SWIG_Py_Void();
   24297             : }
   24298             : 
   24299           0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24300             :   PyObject *resultobj = 0;
   24301             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24302             :   char *arg2 = (char *) 0 ;
   24303           0 :   void *argp1 = 0 ;
   24304             :   int res1 = 0 ;
   24305             :   int res2 ;
   24306           0 :   char *buf2 = 0 ;
   24307           0 :   int alloc2 = 0 ;
   24308           0 :   PyObject * obj0 = 0 ;
   24309           0 :   PyObject * obj1 = 0 ;
   24310             :   
   24311           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenObj_name_set",&obj0,&obj1)) SWIG_fail;
   24312           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 |  0 );
   24313           0 :   if (!SWIG_IsOK(res1)) {
   24314           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_name_set" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24315             :   }
   24316           0 :   arg1 = (scaleTokenObj *)(argp1);
   24317           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24318           0 :   if (!SWIG_IsOK(res2)) {
   24319           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scaleTokenObj_name_set" "', argument " "2"" of type '" "char *""'");
   24320             :   }
   24321           0 :   arg2 = (char *)(buf2);
   24322             :   {
   24323           0 :     if (arg1->name) free((char*)arg1->name);
   24324           0 :     if (arg2) {
   24325           0 :       arg1->name = (char *) malloc(strlen(arg2)+1);
   24326             :       strcpy((char*)arg1->name,arg2);
   24327             :     } else {
   24328           0 :       arg1->name = 0;
   24329             :     }
   24330             :   }
   24331             :   resultobj = SWIG_Py_Void();
   24332           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24333             :   return resultobj;
   24334           0 : fail:
   24335           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24336             :   return NULL;
   24337             : }
   24338             : 
   24339             : 
   24340           0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24341             :   PyObject *resultobj = 0;
   24342             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24343           0 :   void *argp1 = 0 ;
   24344             :   int res1 = 0 ;
   24345           0 :   PyObject * obj0 = 0 ;
   24346             :   char *result = 0 ;
   24347             :   
   24348           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenObj_name_get",&obj0)) SWIG_fail;
   24349           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 |  0 );
   24350           0 :   if (!SWIG_IsOK(res1)) {
   24351           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_name_get" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24352             :   }
   24353           0 :   arg1 = (scaleTokenObj *)(argp1);
   24354           0 :   result = (char *) ((arg1)->name);
   24355           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24356           0 :   return resultobj;
   24357           0 : fail:
   24358             :   return NULL;
   24359             : }
   24360             : 
   24361             : 
   24362           0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_n_entries_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24363             :   PyObject *resultobj = 0;
   24364             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24365             :   int arg2 ;
   24366           0 :   void *argp1 = 0 ;
   24367             :   int res1 = 0 ;
   24368             :   int val2 ;
   24369             :   int ecode2 = 0 ;
   24370           0 :   PyObject * obj0 = 0 ;
   24371           0 :   PyObject * obj1 = 0 ;
   24372             :   
   24373           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenObj_n_entries_set",&obj0,&obj1)) SWIG_fail;
   24374           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 |  0 );
   24375           0 :   if (!SWIG_IsOK(res1)) {
   24376           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_n_entries_set" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24377             :   }
   24378           0 :   arg1 = (scaleTokenObj *)(argp1);
   24379           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   24380           0 :   if (!SWIG_IsOK(ecode2)) {
   24381           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scaleTokenObj_n_entries_set" "', argument " "2"" of type '" "int""'");
   24382             :   } 
   24383             :   arg2 = (int)(val2);
   24384           0 :   if (arg1) (arg1)->n_entries = arg2;
   24385             :   resultobj = SWIG_Py_Void();
   24386           0 :   return resultobj;
   24387           0 : fail:
   24388             :   return NULL;
   24389             : }
   24390             : 
   24391             : 
   24392           0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_n_entries_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24393             :   PyObject *resultobj = 0;
   24394             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24395           0 :   void *argp1 = 0 ;
   24396             :   int res1 = 0 ;
   24397           0 :   PyObject * obj0 = 0 ;
   24398             :   int result;
   24399             :   
   24400           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenObj_n_entries_get",&obj0)) SWIG_fail;
   24401           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 |  0 );
   24402           0 :   if (!SWIG_IsOK(res1)) {
   24403           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_n_entries_get" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24404             :   }
   24405           0 :   arg1 = (scaleTokenObj *)(argp1);
   24406           0 :   result = (int) ((arg1)->n_entries);
   24407             :   resultobj = SWIG_From_int((int)(result));
   24408           0 :   return resultobj;
   24409           0 : fail:
   24410             :   return NULL;
   24411             : }
   24412             : 
   24413             : 
   24414           0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_tokens_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24415             :   PyObject *resultobj = 0;
   24416             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24417             :   scaleTokenEntryObj *arg2 = (scaleTokenEntryObj *) 0 ;
   24418           0 :   void *argp1 = 0 ;
   24419             :   int res1 = 0 ;
   24420           0 :   void *argp2 = 0 ;
   24421             :   int res2 = 0 ;
   24422           0 :   PyObject * obj0 = 0 ;
   24423           0 :   PyObject * obj1 = 0 ;
   24424             :   
   24425           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenObj_tokens_set",&obj0,&obj1)) SWIG_fail;
   24426           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 |  0 );
   24427           0 :   if (!SWIG_IsOK(res1)) {
   24428           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_tokens_set" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24429             :   }
   24430           0 :   arg1 = (scaleTokenObj *)(argp1);
   24431           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_scaleTokenEntryObj, SWIG_POINTER_DISOWN |  0 );
   24432           0 :   if (!SWIG_IsOK(res2)) {
   24433           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scaleTokenObj_tokens_set" "', argument " "2"" of type '" "scaleTokenEntryObj *""'"); 
   24434             :   }
   24435           0 :   arg2 = (scaleTokenEntryObj *)(argp2);
   24436           0 :   if (arg1) (arg1)->tokens = arg2;
   24437             :   resultobj = SWIG_Py_Void();
   24438           0 :   return resultobj;
   24439           0 : fail:
   24440             :   return NULL;
   24441             : }
   24442             : 
   24443             : 
   24444           0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_tokens_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24445             :   PyObject *resultobj = 0;
   24446             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24447           0 :   void *argp1 = 0 ;
   24448             :   int res1 = 0 ;
   24449           0 :   PyObject * obj0 = 0 ;
   24450             :   scaleTokenEntryObj *result = 0 ;
   24451             :   
   24452           0 :   if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenObj_tokens_get",&obj0)) SWIG_fail;
   24453           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 |  0 );
   24454           0 :   if (!SWIG_IsOK(res1)) {
   24455           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_tokens_get" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24456             :   }
   24457           0 :   arg1 = (scaleTokenObj *)(argp1);
   24458           0 :   result = (scaleTokenEntryObj *) ((arg1)->tokens);
   24459           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scaleTokenEntryObj, 0 |  0 );
   24460           0 :   return resultobj;
   24461           0 : fail:
   24462             :   return NULL;
   24463             : }
   24464             : 
   24465             : 
   24466           0 : SWIGINTERN PyObject *_wrap_new_scaleTokenObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24467             :   PyObject *resultobj = 0;
   24468             :   scaleTokenObj *result = 0 ;
   24469             :   
   24470           0 :   if (!PyArg_ParseTuple(args,(char *)":new_scaleTokenObj")) SWIG_fail;
   24471             :   {
   24472           0 :     result = (scaleTokenObj *)calloc(1, sizeof(scaleTokenObj)); {
   24473           0 :       errorObj *ms_error = msGetErrorObj();
   24474             :       
   24475           0 :       switch(ms_error->code) {
   24476             :       case MS_NOERR:
   24477             :         break;
   24478           0 :       case MS_NOTFOUND:
   24479           0 :         msResetErrorList();
   24480           0 :         break;
   24481             :       case -1:
   24482             :         break;
   24483           0 :       case MS_IOERR:
   24484           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   24485           0 :           _raise_ms_exception();
   24486           0 :           msResetErrorList();
   24487           0 :           return NULL;
   24488             :         }
   24489             :       default:
   24490           0 :         _raise_ms_exception();
   24491           0 :         msResetErrorList();
   24492           0 :         return NULL;
   24493             :       }
   24494             :       
   24495             :     }
   24496             :   }
   24497           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scaleTokenObj, SWIG_POINTER_NEW |  0 );
   24498           0 :   return resultobj;
   24499           0 : fail:
   24500             :   return NULL;
   24501             : }
   24502             : 
   24503             : 
   24504           0 : SWIGINTERN PyObject *_wrap_delete_scaleTokenObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24505             :   PyObject *resultobj = 0;
   24506             :   scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
   24507           0 :   void *argp1 = 0 ;
   24508             :   int res1 = 0 ;
   24509           0 :   PyObject * obj0 = 0 ;
   24510             :   
   24511           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_scaleTokenObj",&obj0)) SWIG_fail;
   24512           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, SWIG_POINTER_DISOWN |  0 );
   24513           0 :   if (!SWIG_IsOK(res1)) {
   24514           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scaleTokenObj" "', argument " "1"" of type '" "scaleTokenObj *""'"); 
   24515             :   }
   24516           0 :   arg1 = (scaleTokenObj *)(argp1);
   24517             :   {
   24518           0 :     free((char *) arg1); {
   24519           0 :       errorObj *ms_error = msGetErrorObj();
   24520             :       
   24521           0 :       switch(ms_error->code) {
   24522             :       case MS_NOERR:
   24523             :         break;
   24524           0 :       case MS_NOTFOUND:
   24525           0 :         msResetErrorList();
   24526           0 :         break;
   24527             :       case -1:
   24528             :         break;
   24529           0 :       case MS_IOERR:
   24530           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   24531           0 :           _raise_ms_exception();
   24532           0 :           msResetErrorList();
   24533           0 :           return NULL;
   24534             :         }
   24535             :       default:
   24536           0 :         _raise_ms_exception();
   24537           0 :         msResetErrorList();
   24538           0 :         return NULL;
   24539             :       }
   24540             :       
   24541             :     }
   24542             :   }
   24543             :   resultobj = SWIG_Py_Void();
   24544           0 :   return resultobj;
   24545           0 : fail:
   24546             :   return NULL;
   24547             : }
   24548             : 
   24549             : 
   24550           1 : SWIGINTERN PyObject *scaleTokenObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24551             :   PyObject *obj;
   24552           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   24553           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_scaleTokenObj, SWIG_NewClientData(obj));
   24554           1 :   return SWIG_Py_Void();
   24555             : }
   24556             : 
   24557           0 : SWIGINTERN PyObject *_wrap_layerObj_classitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24558             :   PyObject *resultobj = 0;
   24559             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24560             :   char *arg2 = (char *) 0 ;
   24561           0 :   void *argp1 = 0 ;
   24562             :   int res1 = 0 ;
   24563             :   int res2 ;
   24564           0 :   char *buf2 = 0 ;
   24565           0 :   int alloc2 = 0 ;
   24566           0 :   PyObject * obj0 = 0 ;
   24567           0 :   PyObject * obj1 = 0 ;
   24568             :   
   24569           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_classitem_set",&obj0,&obj1)) SWIG_fail;
   24570           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24571           0 :   if (!SWIG_IsOK(res1)) {
   24572           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classitem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24573             :   }
   24574           0 :   arg1 = (struct layerObj *)(argp1);
   24575           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24576           0 :   if (!SWIG_IsOK(res2)) {
   24577           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_classitem_set" "', argument " "2"" of type '" "char *""'");
   24578             :   }
   24579           0 :   arg2 = (char *)(buf2);
   24580             :   {
   24581           0 :     if (arg1->classitem) free((char*)arg1->classitem);
   24582           0 :     if (arg2) {
   24583           0 :       arg1->classitem = (char *) malloc(strlen(arg2)+1);
   24584             :       strcpy((char*)arg1->classitem,arg2);
   24585             :     } else {
   24586           0 :       arg1->classitem = 0;
   24587             :     }
   24588             :   }
   24589             :   resultobj = SWIG_Py_Void();
   24590           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24591             :   return resultobj;
   24592           0 : fail:
   24593           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24594             :   return NULL;
   24595             : }
   24596             : 
   24597             : 
   24598           0 : SWIGINTERN PyObject *_wrap_layerObj_classitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24599             :   PyObject *resultobj = 0;
   24600             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24601           0 :   void *argp1 = 0 ;
   24602             :   int res1 = 0 ;
   24603           0 :   PyObject * obj0 = 0 ;
   24604             :   char *result = 0 ;
   24605             :   
   24606           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_classitem_get",&obj0)) SWIG_fail;
   24607           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24608           0 :   if (!SWIG_IsOK(res1)) {
   24609           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classitem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24610             :   }
   24611           0 :   arg1 = (struct layerObj *)(argp1);
   24612           0 :   result = (char *) ((arg1)->classitem);
   24613           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24614           0 :   return resultobj;
   24615           0 : fail:
   24616             :   return NULL;
   24617             : }
   24618             : 
   24619             : 
   24620           1 : SWIGINTERN PyObject *_wrap_layerObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24621             :   PyObject *resultobj = 0;
   24622             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24623           1 :   void *argp1 = 0 ;
   24624             :   int res1 = 0 ;
   24625           1 :   PyObject * obj0 = 0 ;
   24626             :   int result;
   24627             :   
   24628           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_refcount_get",&obj0)) SWIG_fail;
   24629           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24630           1 :   if (!SWIG_IsOK(res1)) {
   24631           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_refcount_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24632             :   }
   24633           1 :   arg1 = (struct layerObj *)(argp1);
   24634           1 :   result = (int) ((arg1)->refcount);
   24635             :   resultobj = SWIG_From_int((int)(result));
   24636           1 :   return resultobj;
   24637           0 : fail:
   24638             :   return NULL;
   24639             : }
   24640             : 
   24641             : 
   24642           1 : SWIGINTERN PyObject *_wrap_layerObj_numclasses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24643             :   PyObject *resultobj = 0;
   24644             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24645           1 :   void *argp1 = 0 ;
   24646             :   int res1 = 0 ;
   24647           1 :   PyObject * obj0 = 0 ;
   24648             :   int result;
   24649             :   
   24650           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numclasses_get",&obj0)) SWIG_fail;
   24651           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24652           1 :   if (!SWIG_IsOK(res1)) {
   24653           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numclasses_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24654             :   }
   24655           1 :   arg1 = (struct layerObj *)(argp1);
   24656           1 :   result = (int) ((arg1)->numclasses);
   24657             :   resultobj = SWIG_From_int((int)(result));
   24658           1 :   return resultobj;
   24659           0 : fail:
   24660             :   return NULL;
   24661             : }
   24662             : 
   24663             : 
   24664           0 : SWIGINTERN PyObject *_wrap_layerObj_maxclasses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24665             :   PyObject *resultobj = 0;
   24666             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24667           0 :   void *argp1 = 0 ;
   24668             :   int res1 = 0 ;
   24669           0 :   PyObject * obj0 = 0 ;
   24670             :   int result;
   24671             :   
   24672           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxclasses_get",&obj0)) SWIG_fail;
   24673           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24674           0 :   if (!SWIG_IsOK(res1)) {
   24675           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxclasses_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24676             :   }
   24677           0 :   arg1 = (struct layerObj *)(argp1);
   24678           0 :   result = (int) ((arg1)->maxclasses);
   24679             :   resultobj = SWIG_From_int((int)(result));
   24680           0 :   return resultobj;
   24681           0 : fail:
   24682             :   return NULL;
   24683             : }
   24684             : 
   24685             : 
   24686           1 : SWIGINTERN PyObject *_wrap_layerObj_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24687             :   PyObject *resultobj = 0;
   24688             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24689           1 :   void *argp1 = 0 ;
   24690             :   int res1 = 0 ;
   24691           1 :   PyObject * obj0 = 0 ;
   24692             :   int result;
   24693             :   
   24694           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_index_get",&obj0)) SWIG_fail;
   24695           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24696           1 :   if (!SWIG_IsOK(res1)) {
   24697           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_index_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24698             :   }
   24699           1 :   arg1 = (struct layerObj *)(argp1);
   24700           1 :   result = (int) ((arg1)->index);
   24701             :   resultobj = SWIG_From_int((int)(result));
   24702           1 :   return resultobj;
   24703           0 : fail:
   24704             :   return NULL;
   24705             : }
   24706             : 
   24707             : 
   24708           1 : SWIGINTERN PyObject *_wrap_layerObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24709             :   PyObject *resultobj = 0;
   24710             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24711           1 :   void *argp1 = 0 ;
   24712             :   int res1 = 0 ;
   24713           1 :   PyObject * obj0 = 0 ;
   24714             :   struct mapObj *result = 0 ;
   24715             :   
   24716           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_map_get",&obj0)) SWIG_fail;
   24717           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24718           1 :   if (!SWIG_IsOK(res1)) {
   24719           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_map_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24720             :   }
   24721           1 :   arg1 = (struct layerObj *)(argp1);
   24722           1 :   result = (struct mapObj *) ((arg1)->map);
   24723           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 |  0 );
   24724           1 :   return resultobj;
   24725           0 : fail:
   24726             :   return NULL;
   24727             : }
   24728             : 
   24729             : 
   24730           0 : SWIGINTERN PyObject *_wrap_layerObj_header_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24731             :   PyObject *resultobj = 0;
   24732             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24733             :   char *arg2 = (char *) 0 ;
   24734           0 :   void *argp1 = 0 ;
   24735             :   int res1 = 0 ;
   24736             :   int res2 ;
   24737           0 :   char *buf2 = 0 ;
   24738           0 :   int alloc2 = 0 ;
   24739           0 :   PyObject * obj0 = 0 ;
   24740           0 :   PyObject * obj1 = 0 ;
   24741             :   
   24742           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_header_set",&obj0,&obj1)) SWIG_fail;
   24743           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24744           0 :   if (!SWIG_IsOK(res1)) {
   24745           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_header_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24746             :   }
   24747           0 :   arg1 = (struct layerObj *)(argp1);
   24748           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24749           0 :   if (!SWIG_IsOK(res2)) {
   24750           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_header_set" "', argument " "2"" of type '" "char *""'");
   24751             :   }
   24752           0 :   arg2 = (char *)(buf2);
   24753             :   {
   24754           0 :     if (arg1->header) free((char*)arg1->header);
   24755           0 :     if (arg2) {
   24756           0 :       arg1->header = (char *) malloc(strlen(arg2)+1);
   24757             :       strcpy((char*)arg1->header,arg2);
   24758             :     } else {
   24759           0 :       arg1->header = 0;
   24760             :     }
   24761             :   }
   24762             :   resultobj = SWIG_Py_Void();
   24763           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24764             :   return resultobj;
   24765           0 : fail:
   24766           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24767             :   return NULL;
   24768             : }
   24769             : 
   24770             : 
   24771           0 : SWIGINTERN PyObject *_wrap_layerObj_header_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24772             :   PyObject *resultobj = 0;
   24773             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24774           0 :   void *argp1 = 0 ;
   24775             :   int res1 = 0 ;
   24776           0 :   PyObject * obj0 = 0 ;
   24777             :   char *result = 0 ;
   24778             :   
   24779           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_header_get",&obj0)) SWIG_fail;
   24780           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24781           0 :   if (!SWIG_IsOK(res1)) {
   24782           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_header_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24783             :   }
   24784           0 :   arg1 = (struct layerObj *)(argp1);
   24785           0 :   result = (char *) ((arg1)->header);
   24786           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24787           0 :   return resultobj;
   24788           0 : fail:
   24789             :   return NULL;
   24790             : }
   24791             : 
   24792             : 
   24793           0 : SWIGINTERN PyObject *_wrap_layerObj_footer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24794             :   PyObject *resultobj = 0;
   24795             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24796             :   char *arg2 = (char *) 0 ;
   24797           0 :   void *argp1 = 0 ;
   24798             :   int res1 = 0 ;
   24799             :   int res2 ;
   24800           0 :   char *buf2 = 0 ;
   24801           0 :   int alloc2 = 0 ;
   24802           0 :   PyObject * obj0 = 0 ;
   24803           0 :   PyObject * obj1 = 0 ;
   24804             :   
   24805           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_footer_set",&obj0,&obj1)) SWIG_fail;
   24806           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24807           0 :   if (!SWIG_IsOK(res1)) {
   24808           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_footer_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24809             :   }
   24810           0 :   arg1 = (struct layerObj *)(argp1);
   24811           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24812           0 :   if (!SWIG_IsOK(res2)) {
   24813           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_footer_set" "', argument " "2"" of type '" "char *""'");
   24814             :   }
   24815           0 :   arg2 = (char *)(buf2);
   24816             :   {
   24817           0 :     if (arg1->footer) free((char*)arg1->footer);
   24818           0 :     if (arg2) {
   24819           0 :       arg1->footer = (char *) malloc(strlen(arg2)+1);
   24820             :       strcpy((char*)arg1->footer,arg2);
   24821             :     } else {
   24822           0 :       arg1->footer = 0;
   24823             :     }
   24824             :   }
   24825             :   resultobj = SWIG_Py_Void();
   24826           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24827             :   return resultobj;
   24828           0 : fail:
   24829           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24830             :   return NULL;
   24831             : }
   24832             : 
   24833             : 
   24834           0 : SWIGINTERN PyObject *_wrap_layerObj_footer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24835             :   PyObject *resultobj = 0;
   24836             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24837           0 :   void *argp1 = 0 ;
   24838             :   int res1 = 0 ;
   24839           0 :   PyObject * obj0 = 0 ;
   24840             :   char *result = 0 ;
   24841             :   
   24842           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_footer_get",&obj0)) SWIG_fail;
   24843           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24844           0 :   if (!SWIG_IsOK(res1)) {
   24845           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_footer_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24846             :   }
   24847           0 :   arg1 = (struct layerObj *)(argp1);
   24848           0 :   result = (char *) ((arg1)->footer);
   24849           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24850           0 :   return resultobj;
   24851           0 : fail:
   24852             :   return NULL;
   24853             : }
   24854             : 
   24855             : 
   24856           1 : SWIGINTERN PyObject *_wrap_layerObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24857             :   PyObject *resultobj = 0;
   24858             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24859             :   char *arg2 = (char *) 0 ;
   24860           1 :   void *argp1 = 0 ;
   24861             :   int res1 = 0 ;
   24862             :   int res2 ;
   24863           1 :   char *buf2 = 0 ;
   24864           1 :   int alloc2 = 0 ;
   24865           1 :   PyObject * obj0 = 0 ;
   24866           1 :   PyObject * obj1 = 0 ;
   24867             :   
   24868           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_template_set",&obj0,&obj1)) SWIG_fail;
   24869           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24870           1 :   if (!SWIG_IsOK(res1)) {
   24871           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_template_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24872             :   }
   24873           1 :   arg1 = (struct layerObj *)(argp1);
   24874           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24875           1 :   if (!SWIG_IsOK(res2)) {
   24876           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_template_set" "', argument " "2"" of type '" "char *""'");
   24877             :   }
   24878           1 :   arg2 = (char *)(buf2);
   24879             :   {
   24880           1 :     if (arg1->template) free((char*)arg1->template);
   24881           1 :     if (arg2) {
   24882           1 :       arg1->template = (char *) malloc(strlen(arg2)+1);
   24883             :       strcpy((char*)arg1->template,arg2);
   24884             :     } else {
   24885           0 :       arg1->template = 0;
   24886             :     }
   24887             :   }
   24888             :   resultobj = SWIG_Py_Void();
   24889           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24890             :   return resultobj;
   24891           0 : fail:
   24892           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24893             :   return NULL;
   24894             : }
   24895             : 
   24896             : 
   24897           0 : SWIGINTERN PyObject *_wrap_layerObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24898             :   PyObject *resultobj = 0;
   24899             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24900           0 :   void *argp1 = 0 ;
   24901             :   int res1 = 0 ;
   24902           0 :   PyObject * obj0 = 0 ;
   24903             :   char *result = 0 ;
   24904             :   
   24905           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_template_get",&obj0)) SWIG_fail;
   24906           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24907           0 :   if (!SWIG_IsOK(res1)) {
   24908           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_template_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24909             :   }
   24910           0 :   arg1 = (struct layerObj *)(argp1);
   24911           0 :   result = (char *) ((arg1)->template);
   24912           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24913           0 :   return resultobj;
   24914           0 : fail:
   24915             :   return NULL;
   24916             : }
   24917             : 
   24918             : 
   24919           1 : SWIGINTERN PyObject *_wrap_layerObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24920             :   PyObject *resultobj = 0;
   24921             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24922             :   char *arg2 = (char *) 0 ;
   24923           1 :   void *argp1 = 0 ;
   24924             :   int res1 = 0 ;
   24925             :   int res2 ;
   24926           1 :   char *buf2 = 0 ;
   24927           1 :   int alloc2 = 0 ;
   24928           1 :   PyObject * obj0 = 0 ;
   24929           1 :   PyObject * obj1 = 0 ;
   24930             :   
   24931           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_name_set",&obj0,&obj1)) SWIG_fail;
   24932           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24933           1 :   if (!SWIG_IsOK(res1)) {
   24934           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_name_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24935             :   }
   24936           1 :   arg1 = (struct layerObj *)(argp1);
   24937           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   24938           1 :   if (!SWIG_IsOK(res2)) {
   24939           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_name_set" "', argument " "2"" of type '" "char *""'");
   24940             :   }
   24941           1 :   arg2 = (char *)(buf2);
   24942             :   {
   24943           1 :     if (arg1->name) free((char*)arg1->name);
   24944           1 :     if (arg2) {
   24945           1 :       arg1->name = (char *) malloc(strlen(arg2)+1);
   24946             :       strcpy((char*)arg1->name,arg2);
   24947             :     } else {
   24948           0 :       arg1->name = 0;
   24949             :     }
   24950             :   }
   24951             :   resultobj = SWIG_Py_Void();
   24952           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24953             :   return resultobj;
   24954           0 : fail:
   24955           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   24956             :   return NULL;
   24957             : }
   24958             : 
   24959             : 
   24960           1 : SWIGINTERN PyObject *_wrap_layerObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24961             :   PyObject *resultobj = 0;
   24962             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24963           1 :   void *argp1 = 0 ;
   24964             :   int res1 = 0 ;
   24965           1 :   PyObject * obj0 = 0 ;
   24966             :   char *result = 0 ;
   24967             :   
   24968           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_name_get",&obj0)) SWIG_fail;
   24969           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24970           1 :   if (!SWIG_IsOK(res1)) {
   24971           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_name_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24972             :   }
   24973           1 :   arg1 = (struct layerObj *)(argp1);
   24974           1 :   result = (char *) ((arg1)->name);
   24975           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   24976           1 :   return resultobj;
   24977           0 : fail:
   24978             :   return NULL;
   24979             : }
   24980             : 
   24981             : 
   24982           0 : SWIGINTERN PyObject *_wrap_layerObj_group_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   24983             :   PyObject *resultobj = 0;
   24984             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   24985             :   char *arg2 = (char *) 0 ;
   24986           0 :   void *argp1 = 0 ;
   24987             :   int res1 = 0 ;
   24988             :   int res2 ;
   24989           0 :   char *buf2 = 0 ;
   24990           0 :   int alloc2 = 0 ;
   24991           0 :   PyObject * obj0 = 0 ;
   24992           0 :   PyObject * obj1 = 0 ;
   24993             :   
   24994           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_group_set",&obj0,&obj1)) SWIG_fail;
   24995           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   24996           0 :   if (!SWIG_IsOK(res1)) {
   24997           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_group_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   24998             :   }
   24999           0 :   arg1 = (struct layerObj *)(argp1);
   25000           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   25001           0 :   if (!SWIG_IsOK(res2)) {
   25002           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_group_set" "', argument " "2"" of type '" "char *""'");
   25003             :   }
   25004           0 :   arg2 = (char *)(buf2);
   25005             :   {
   25006           0 :     if (arg1->group) free((char*)arg1->group);
   25007           0 :     if (arg2) {
   25008           0 :       arg1->group = (char *) malloc(strlen(arg2)+1);
   25009             :       strcpy((char*)arg1->group,arg2);
   25010             :     } else {
   25011           0 :       arg1->group = 0;
   25012             :     }
   25013             :   }
   25014             :   resultobj = SWIG_Py_Void();
   25015           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   25016             :   return resultobj;
   25017           0 : fail:
   25018           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   25019             :   return NULL;
   25020             : }
   25021             : 
   25022             : 
   25023           0 : SWIGINTERN PyObject *_wrap_layerObj_group_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25024             :   PyObject *resultobj = 0;
   25025             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25026           0 :   void *argp1 = 0 ;
   25027             :   int res1 = 0 ;
   25028           0 :   PyObject * obj0 = 0 ;
   25029             :   char *result = 0 ;
   25030             :   
   25031           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_group_get",&obj0)) SWIG_fail;
   25032           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25033           0 :   if (!SWIG_IsOK(res1)) {
   25034           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_group_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25035             :   }
   25036           0 :   arg1 = (struct layerObj *)(argp1);
   25037           0 :   result = (char *) ((arg1)->group);
   25038           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   25039           0 :   return resultobj;
   25040           0 : fail:
   25041             :   return NULL;
   25042             : }
   25043             : 
   25044             : 
   25045           1 : SWIGINTERN PyObject *_wrap_layerObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25046             :   PyObject *resultobj = 0;
   25047             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25048             :   int arg2 ;
   25049           1 :   void *argp1 = 0 ;
   25050             :   int res1 = 0 ;
   25051             :   int val2 ;
   25052             :   int ecode2 = 0 ;
   25053           1 :   PyObject * obj0 = 0 ;
   25054           1 :   PyObject * obj1 = 0 ;
   25055             :   
   25056           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_status_set",&obj0,&obj1)) SWIG_fail;
   25057           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25058           1 :   if (!SWIG_IsOK(res1)) {
   25059           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_status_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25060             :   }
   25061           1 :   arg1 = (struct layerObj *)(argp1);
   25062           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25063           1 :   if (!SWIG_IsOK(ecode2)) {
   25064           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_status_set" "', argument " "2"" of type '" "int""'");
   25065             :   } 
   25066             :   arg2 = (int)(val2);
   25067           1 :   if (arg1) (arg1)->status = arg2;
   25068             :   resultobj = SWIG_Py_Void();
   25069           1 :   return resultobj;
   25070           0 : fail:
   25071             :   return NULL;
   25072             : }
   25073             : 
   25074             : 
   25075           0 : SWIGINTERN PyObject *_wrap_layerObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25076             :   PyObject *resultobj = 0;
   25077             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25078           0 :   void *argp1 = 0 ;
   25079             :   int res1 = 0 ;
   25080           0 :   PyObject * obj0 = 0 ;
   25081             :   int result;
   25082             :   
   25083           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_status_get",&obj0)) SWIG_fail;
   25084           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25085           0 :   if (!SWIG_IsOK(res1)) {
   25086           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_status_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25087             :   }
   25088           0 :   arg1 = (struct layerObj *)(argp1);
   25089           0 :   result = (int) ((arg1)->status);
   25090             :   resultobj = SWIG_From_int((int)(result));
   25091           0 :   return resultobj;
   25092           0 : fail:
   25093             :   return NULL;
   25094             : }
   25095             : 
   25096             : 
   25097           0 : SWIGINTERN PyObject *_wrap_layerObj_rendermode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25098             :   PyObject *resultobj = 0;
   25099             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25100             :   enum MS_RENDER_MODE arg2 ;
   25101           0 :   void *argp1 = 0 ;
   25102             :   int res1 = 0 ;
   25103             :   int val2 ;
   25104             :   int ecode2 = 0 ;
   25105           0 :   PyObject * obj0 = 0 ;
   25106           0 :   PyObject * obj1 = 0 ;
   25107             :   
   25108           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_rendermode_set",&obj0,&obj1)) SWIG_fail;
   25109           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25110           0 :   if (!SWIG_IsOK(res1)) {
   25111           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_rendermode_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25112             :   }
   25113           0 :   arg1 = (struct layerObj *)(argp1);
   25114           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25115           0 :   if (!SWIG_IsOK(ecode2)) {
   25116           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_rendermode_set" "', argument " "2"" of type '" "enum MS_RENDER_MODE""'");
   25117             :   } 
   25118           0 :   arg2 = (enum MS_RENDER_MODE)(val2);
   25119           0 :   if (arg1) (arg1)->rendermode = arg2;
   25120             :   resultobj = SWIG_Py_Void();
   25121           0 :   return resultobj;
   25122           0 : fail:
   25123             :   return NULL;
   25124             : }
   25125             : 
   25126             : 
   25127           0 : SWIGINTERN PyObject *_wrap_layerObj_rendermode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25128             :   PyObject *resultobj = 0;
   25129             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25130           0 :   void *argp1 = 0 ;
   25131             :   int res1 = 0 ;
   25132           0 :   PyObject * obj0 = 0 ;
   25133             :   enum MS_RENDER_MODE result;
   25134             :   
   25135           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_rendermode_get",&obj0)) SWIG_fail;
   25136           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25137           0 :   if (!SWIG_IsOK(res1)) {
   25138           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_rendermode_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25139             :   }
   25140           0 :   arg1 = (struct layerObj *)(argp1);
   25141           0 :   result = (enum MS_RENDER_MODE) ((arg1)->rendermode);
   25142           0 :   resultobj = SWIG_From_int((int)(result));
   25143           0 :   return resultobj;
   25144           0 : fail:
   25145             :   return NULL;
   25146             : }
   25147             : 
   25148             : 
   25149           1 : SWIGINTERN PyObject *_wrap_layerObj_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25150             :   PyObject *resultobj = 0;
   25151             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25152             :   char *arg2 = (char *) 0 ;
   25153           1 :   void *argp1 = 0 ;
   25154             :   int res1 = 0 ;
   25155             :   int res2 ;
   25156           1 :   char *buf2 = 0 ;
   25157           1 :   int alloc2 = 0 ;
   25158           1 :   PyObject * obj0 = 0 ;
   25159           1 :   PyObject * obj1 = 0 ;
   25160             :   
   25161           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_data_set",&obj0,&obj1)) SWIG_fail;
   25162           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25163           1 :   if (!SWIG_IsOK(res1)) {
   25164           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_data_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25165             :   }
   25166           1 :   arg1 = (struct layerObj *)(argp1);
   25167           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   25168           1 :   if (!SWIG_IsOK(res2)) {
   25169           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_data_set" "', argument " "2"" of type '" "char *""'");
   25170             :   }
   25171           1 :   arg2 = (char *)(buf2);
   25172             :   {
   25173           1 :     if (arg1->data) free((char*)arg1->data);
   25174           1 :     if (arg2) {
   25175           1 :       arg1->data = (char *) malloc(strlen(arg2)+1);
   25176             :       strcpy((char*)arg1->data,arg2);
   25177             :     } else {
   25178           0 :       arg1->data = 0;
   25179             :     }
   25180             :   }
   25181             :   resultobj = SWIG_Py_Void();
   25182           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   25183             :   return resultobj;
   25184           0 : fail:
   25185           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   25186             :   return NULL;
   25187             : }
   25188             : 
   25189             : 
   25190           1 : SWIGINTERN PyObject *_wrap_layerObj_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25191             :   PyObject *resultobj = 0;
   25192             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25193           1 :   void *argp1 = 0 ;
   25194             :   int res1 = 0 ;
   25195           1 :   PyObject * obj0 = 0 ;
   25196             :   char *result = 0 ;
   25197             :   
   25198           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_data_get",&obj0)) SWIG_fail;
   25199           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25200           1 :   if (!SWIG_IsOK(res1)) {
   25201           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_data_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25202             :   }
   25203           1 :   arg1 = (struct layerObj *)(argp1);
   25204           1 :   result = (char *) ((arg1)->data);
   25205           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   25206           1 :   return resultobj;
   25207           0 : fail:
   25208             :   return NULL;
   25209             : }
   25210             : 
   25211             : 
   25212           1 : SWIGINTERN PyObject *_wrap_layerObj_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25213             :   PyObject *resultobj = 0;
   25214             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25215             :   enum MS_LAYER_TYPE arg2 ;
   25216           1 :   void *argp1 = 0 ;
   25217             :   int res1 = 0 ;
   25218             :   int val2 ;
   25219             :   int ecode2 = 0 ;
   25220           1 :   PyObject * obj0 = 0 ;
   25221           1 :   PyObject * obj1 = 0 ;
   25222             :   
   25223           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_type_set",&obj0,&obj1)) SWIG_fail;
   25224           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25225           1 :   if (!SWIG_IsOK(res1)) {
   25226           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_type_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25227             :   }
   25228           1 :   arg1 = (struct layerObj *)(argp1);
   25229           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25230           1 :   if (!SWIG_IsOK(ecode2)) {
   25231           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_type_set" "', argument " "2"" of type '" "enum MS_LAYER_TYPE""'");
   25232             :   } 
   25233           1 :   arg2 = (enum MS_LAYER_TYPE)(val2);
   25234           1 :   if (arg1) (arg1)->type = arg2;
   25235             :   resultobj = SWIG_Py_Void();
   25236           1 :   return resultobj;
   25237           0 : fail:
   25238             :   return NULL;
   25239             : }
   25240             : 
   25241             : 
   25242           1 : SWIGINTERN PyObject *_wrap_layerObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25243             :   PyObject *resultobj = 0;
   25244             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25245           1 :   void *argp1 = 0 ;
   25246             :   int res1 = 0 ;
   25247           1 :   PyObject * obj0 = 0 ;
   25248             :   enum MS_LAYER_TYPE result;
   25249             :   
   25250           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_type_get",&obj0)) SWIG_fail;
   25251           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25252           1 :   if (!SWIG_IsOK(res1)) {
   25253           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_type_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25254             :   }
   25255           1 :   arg1 = (struct layerObj *)(argp1);
   25256           1 :   result = (enum MS_LAYER_TYPE) ((arg1)->type);
   25257           1 :   resultobj = SWIG_From_int((int)(result));
   25258           1 :   return resultobj;
   25259           0 : fail:
   25260             :   return NULL;
   25261             : }
   25262             : 
   25263             : 
   25264           0 : SWIGINTERN PyObject *_wrap_layerObj_tolerance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25265             :   PyObject *resultobj = 0;
   25266             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25267             :   double arg2 ;
   25268           0 :   void *argp1 = 0 ;
   25269             :   int res1 = 0 ;
   25270             :   double val2 ;
   25271             :   int ecode2 = 0 ;
   25272           0 :   PyObject * obj0 = 0 ;
   25273           0 :   PyObject * obj1 = 0 ;
   25274             :   
   25275           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tolerance_set",&obj0,&obj1)) SWIG_fail;
   25276           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25277           0 :   if (!SWIG_IsOK(res1)) {
   25278           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tolerance_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25279             :   }
   25280           0 :   arg1 = (struct layerObj *)(argp1);
   25281           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25282           0 :   if (!SWIG_IsOK(ecode2)) {
   25283           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_tolerance_set" "', argument " "2"" of type '" "double""'");
   25284             :   } 
   25285           0 :   arg2 = (double)(val2);
   25286           0 :   if (arg1) (arg1)->tolerance = arg2;
   25287             :   resultobj = SWIG_Py_Void();
   25288           0 :   return resultobj;
   25289           0 : fail:
   25290             :   return NULL;
   25291             : }
   25292             : 
   25293             : 
   25294           0 : SWIGINTERN PyObject *_wrap_layerObj_tolerance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25295             :   PyObject *resultobj = 0;
   25296             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25297           0 :   void *argp1 = 0 ;
   25298             :   int res1 = 0 ;
   25299           0 :   PyObject * obj0 = 0 ;
   25300             :   double result;
   25301             :   
   25302           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tolerance_get",&obj0)) SWIG_fail;
   25303           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25304           0 :   if (!SWIG_IsOK(res1)) {
   25305           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tolerance_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25306             :   }
   25307           0 :   arg1 = (struct layerObj *)(argp1);
   25308           0 :   result = (double) ((arg1)->tolerance);
   25309           0 :   resultobj = SWIG_From_double((double)(result));
   25310           0 :   return resultobj;
   25311           0 : fail:
   25312             :   return NULL;
   25313             : }
   25314             : 
   25315             : 
   25316           0 : SWIGINTERN PyObject *_wrap_layerObj_toleranceunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25317             :   PyObject *resultobj = 0;
   25318             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25319             :   int arg2 ;
   25320           0 :   void *argp1 = 0 ;
   25321             :   int res1 = 0 ;
   25322             :   int val2 ;
   25323             :   int ecode2 = 0 ;
   25324           0 :   PyObject * obj0 = 0 ;
   25325           0 :   PyObject * obj1 = 0 ;
   25326             :   
   25327           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_toleranceunits_set",&obj0,&obj1)) SWIG_fail;
   25328           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25329           0 :   if (!SWIG_IsOK(res1)) {
   25330           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_toleranceunits_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25331             :   }
   25332           0 :   arg1 = (struct layerObj *)(argp1);
   25333           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25334           0 :   if (!SWIG_IsOK(ecode2)) {
   25335           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_toleranceunits_set" "', argument " "2"" of type '" "int""'");
   25336             :   } 
   25337             :   arg2 = (int)(val2);
   25338           0 :   if (arg1) (arg1)->toleranceunits = arg2;
   25339             :   resultobj = SWIG_Py_Void();
   25340           0 :   return resultobj;
   25341           0 : fail:
   25342             :   return NULL;
   25343             : }
   25344             : 
   25345             : 
   25346           0 : SWIGINTERN PyObject *_wrap_layerObj_toleranceunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25347             :   PyObject *resultobj = 0;
   25348             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25349           0 :   void *argp1 = 0 ;
   25350             :   int res1 = 0 ;
   25351           0 :   PyObject * obj0 = 0 ;
   25352             :   int result;
   25353             :   
   25354           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_toleranceunits_get",&obj0)) SWIG_fail;
   25355           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25356           0 :   if (!SWIG_IsOK(res1)) {
   25357           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_toleranceunits_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25358             :   }
   25359           0 :   arg1 = (struct layerObj *)(argp1);
   25360           0 :   result = (int) ((arg1)->toleranceunits);
   25361             :   resultobj = SWIG_From_int((int)(result));
   25362           0 :   return resultobj;
   25363           0 : fail:
   25364             :   return NULL;
   25365             : }
   25366             : 
   25367             : 
   25368           0 : SWIGINTERN PyObject *_wrap_layerObj_symbolscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25369             :   PyObject *resultobj = 0;
   25370             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25371             :   double arg2 ;
   25372           0 :   void *argp1 = 0 ;
   25373             :   int res1 = 0 ;
   25374             :   double val2 ;
   25375             :   int ecode2 = 0 ;
   25376           0 :   PyObject * obj0 = 0 ;
   25377           0 :   PyObject * obj1 = 0 ;
   25378             :   
   25379           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_symbolscaledenom_set",&obj0,&obj1)) SWIG_fail;
   25380           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25381           0 :   if (!SWIG_IsOK(res1)) {
   25382           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_symbolscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25383             :   }
   25384           0 :   arg1 = (struct layerObj *)(argp1);
   25385           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25386           0 :   if (!SWIG_IsOK(ecode2)) {
   25387           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_symbolscaledenom_set" "', argument " "2"" of type '" "double""'");
   25388             :   } 
   25389           0 :   arg2 = (double)(val2);
   25390           0 :   if (arg1) (arg1)->symbolscaledenom = arg2;
   25391             :   resultobj = SWIG_Py_Void();
   25392           0 :   return resultobj;
   25393           0 : fail:
   25394             :   return NULL;
   25395             : }
   25396             : 
   25397             : 
   25398           0 : SWIGINTERN PyObject *_wrap_layerObj_symbolscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25399             :   PyObject *resultobj = 0;
   25400             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25401           0 :   void *argp1 = 0 ;
   25402             :   int res1 = 0 ;
   25403           0 :   PyObject * obj0 = 0 ;
   25404             :   double result;
   25405             :   
   25406           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_symbolscaledenom_get",&obj0)) SWIG_fail;
   25407           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25408           0 :   if (!SWIG_IsOK(res1)) {
   25409           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_symbolscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25410             :   }
   25411           0 :   arg1 = (struct layerObj *)(argp1);
   25412           0 :   result = (double) ((arg1)->symbolscaledenom);
   25413           0 :   resultobj = SWIG_From_double((double)(result));
   25414           0 :   return resultobj;
   25415           0 : fail:
   25416             :   return NULL;
   25417             : }
   25418             : 
   25419             : 
   25420           1 : SWIGINTERN PyObject *_wrap_layerObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25421             :   PyObject *resultobj = 0;
   25422             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25423             :   double arg2 ;
   25424           1 :   void *argp1 = 0 ;
   25425             :   int res1 = 0 ;
   25426             :   double val2 ;
   25427             :   int ecode2 = 0 ;
   25428           1 :   PyObject * obj0 = 0 ;
   25429           1 :   PyObject * obj1 = 0 ;
   25430             :   
   25431           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
   25432           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25433           1 :   if (!SWIG_IsOK(res1)) {
   25434           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25435             :   }
   25436           1 :   arg1 = (struct layerObj *)(argp1);
   25437           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25438           1 :   if (!SWIG_IsOK(ecode2)) {
   25439           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
   25440             :   } 
   25441           1 :   arg2 = (double)(val2);
   25442           1 :   if (arg1) (arg1)->minscaledenom = arg2;
   25443             :   resultobj = SWIG_Py_Void();
   25444           1 :   return resultobj;
   25445           0 : fail:
   25446             :   return NULL;
   25447             : }
   25448             : 
   25449             : 
   25450           0 : SWIGINTERN PyObject *_wrap_layerObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25451             :   PyObject *resultobj = 0;
   25452             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25453           0 :   void *argp1 = 0 ;
   25454             :   int res1 = 0 ;
   25455           0 :   PyObject * obj0 = 0 ;
   25456             :   double result;
   25457             :   
   25458           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_minscaledenom_get",&obj0)) SWIG_fail;
   25459           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25460           0 :   if (!SWIG_IsOK(res1)) {
   25461           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25462             :   }
   25463           0 :   arg1 = (struct layerObj *)(argp1);
   25464           0 :   result = (double) ((arg1)->minscaledenom);
   25465           0 :   resultobj = SWIG_From_double((double)(result));
   25466           0 :   return resultobj;
   25467           0 : fail:
   25468             :   return NULL;
   25469             : }
   25470             : 
   25471             : 
   25472           1 : SWIGINTERN PyObject *_wrap_layerObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25473             :   PyObject *resultobj = 0;
   25474             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25475             :   double arg2 ;
   25476           1 :   void *argp1 = 0 ;
   25477             :   int res1 = 0 ;
   25478             :   double val2 ;
   25479             :   int ecode2 = 0 ;
   25480           1 :   PyObject * obj0 = 0 ;
   25481           1 :   PyObject * obj1 = 0 ;
   25482             :   
   25483           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
   25484           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25485           1 :   if (!SWIG_IsOK(res1)) {
   25486           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25487             :   }
   25488           1 :   arg1 = (struct layerObj *)(argp1);
   25489           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25490           1 :   if (!SWIG_IsOK(ecode2)) {
   25491           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
   25492             :   } 
   25493           1 :   arg2 = (double)(val2);
   25494           1 :   if (arg1) (arg1)->maxscaledenom = arg2;
   25495             :   resultobj = SWIG_Py_Void();
   25496           1 :   return resultobj;
   25497           0 : fail:
   25498             :   return NULL;
   25499             : }
   25500             : 
   25501             : 
   25502           0 : SWIGINTERN PyObject *_wrap_layerObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25503             :   PyObject *resultobj = 0;
   25504             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25505           0 :   void *argp1 = 0 ;
   25506             :   int res1 = 0 ;
   25507           0 :   PyObject * obj0 = 0 ;
   25508             :   double result;
   25509             :   
   25510           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxscaledenom_get",&obj0)) SWIG_fail;
   25511           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25512           0 :   if (!SWIG_IsOK(res1)) {
   25513           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25514             :   }
   25515           0 :   arg1 = (struct layerObj *)(argp1);
   25516           0 :   result = (double) ((arg1)->maxscaledenom);
   25517           0 :   resultobj = SWIG_From_double((double)(result));
   25518           0 :   return resultobj;
   25519           0 : fail:
   25520             :   return NULL;
   25521             : }
   25522             : 
   25523             : 
   25524           0 : SWIGINTERN PyObject *_wrap_layerObj_minfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25525             :   PyObject *resultobj = 0;
   25526             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25527             :   int arg2 ;
   25528           0 :   void *argp1 = 0 ;
   25529             :   int res1 = 0 ;
   25530             :   int val2 ;
   25531             :   int ecode2 = 0 ;
   25532           0 :   PyObject * obj0 = 0 ;
   25533           0 :   PyObject * obj1 = 0 ;
   25534             :   
   25535           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_minfeaturesize_set",&obj0,&obj1)) SWIG_fail;
   25536           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25537           0 :   if (!SWIG_IsOK(res1)) {
   25538           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minfeaturesize_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25539             :   }
   25540           0 :   arg1 = (struct layerObj *)(argp1);
   25541           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25542           0 :   if (!SWIG_IsOK(ecode2)) {
   25543           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_minfeaturesize_set" "', argument " "2"" of type '" "int""'");
   25544             :   } 
   25545             :   arg2 = (int)(val2);
   25546           0 :   if (arg1) (arg1)->minfeaturesize = arg2;
   25547             :   resultobj = SWIG_Py_Void();
   25548           0 :   return resultobj;
   25549           0 : fail:
   25550             :   return NULL;
   25551             : }
   25552             : 
   25553             : 
   25554           0 : SWIGINTERN PyObject *_wrap_layerObj_minfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25555             :   PyObject *resultobj = 0;
   25556             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25557           0 :   void *argp1 = 0 ;
   25558             :   int res1 = 0 ;
   25559           0 :   PyObject * obj0 = 0 ;
   25560             :   int result;
   25561             :   
   25562           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_minfeaturesize_get",&obj0)) SWIG_fail;
   25563           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25564           0 :   if (!SWIG_IsOK(res1)) {
   25565           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minfeaturesize_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25566             :   }
   25567           0 :   arg1 = (struct layerObj *)(argp1);
   25568           0 :   result = (int) ((arg1)->minfeaturesize);
   25569             :   resultobj = SWIG_From_int((int)(result));
   25570           0 :   return resultobj;
   25571           0 : fail:
   25572             :   return NULL;
   25573             : }
   25574             : 
   25575             : 
   25576           0 : SWIGINTERN PyObject *_wrap_layerObj_labelminscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25577             :   PyObject *resultobj = 0;
   25578             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25579             :   double arg2 ;
   25580           0 :   void *argp1 = 0 ;
   25581             :   int res1 = 0 ;
   25582             :   double val2 ;
   25583             :   int ecode2 = 0 ;
   25584           0 :   PyObject * obj0 = 0 ;
   25585           0 :   PyObject * obj1 = 0 ;
   25586             :   
   25587           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelminscaledenom_set",&obj0,&obj1)) SWIG_fail;
   25588           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25589           0 :   if (!SWIG_IsOK(res1)) {
   25590           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelminscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25591             :   }
   25592           0 :   arg1 = (struct layerObj *)(argp1);
   25593           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25594           0 :   if (!SWIG_IsOK(ecode2)) {
   25595           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_labelminscaledenom_set" "', argument " "2"" of type '" "double""'");
   25596             :   } 
   25597           0 :   arg2 = (double)(val2);
   25598           0 :   if (arg1) (arg1)->labelminscaledenom = arg2;
   25599             :   resultobj = SWIG_Py_Void();
   25600           0 :   return resultobj;
   25601           0 : fail:
   25602             :   return NULL;
   25603             : }
   25604             : 
   25605             : 
   25606           0 : SWIGINTERN PyObject *_wrap_layerObj_labelminscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25607             :   PyObject *resultobj = 0;
   25608             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25609           0 :   void *argp1 = 0 ;
   25610             :   int res1 = 0 ;
   25611           0 :   PyObject * obj0 = 0 ;
   25612             :   double result;
   25613             :   
   25614           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelminscaledenom_get",&obj0)) SWIG_fail;
   25615           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25616           0 :   if (!SWIG_IsOK(res1)) {
   25617           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelminscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25618             :   }
   25619           0 :   arg1 = (struct layerObj *)(argp1);
   25620           0 :   result = (double) ((arg1)->labelminscaledenom);
   25621           0 :   resultobj = SWIG_From_double((double)(result));
   25622           0 :   return resultobj;
   25623           0 : fail:
   25624             :   return NULL;
   25625             : }
   25626             : 
   25627             : 
   25628           0 : SWIGINTERN PyObject *_wrap_layerObj_labelmaxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25629             :   PyObject *resultobj = 0;
   25630             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25631             :   double arg2 ;
   25632           0 :   void *argp1 = 0 ;
   25633             :   int res1 = 0 ;
   25634             :   double val2 ;
   25635             :   int ecode2 = 0 ;
   25636           0 :   PyObject * obj0 = 0 ;
   25637           0 :   PyObject * obj1 = 0 ;
   25638             :   
   25639           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelmaxscaledenom_set",&obj0,&obj1)) SWIG_fail;
   25640           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25641           0 :   if (!SWIG_IsOK(res1)) {
   25642           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelmaxscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25643             :   }
   25644           0 :   arg1 = (struct layerObj *)(argp1);
   25645           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25646           0 :   if (!SWIG_IsOK(ecode2)) {
   25647           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_labelmaxscaledenom_set" "', argument " "2"" of type '" "double""'");
   25648             :   } 
   25649           0 :   arg2 = (double)(val2);
   25650           0 :   if (arg1) (arg1)->labelmaxscaledenom = arg2;
   25651             :   resultobj = SWIG_Py_Void();
   25652           0 :   return resultobj;
   25653           0 : fail:
   25654             :   return NULL;
   25655             : }
   25656             : 
   25657             : 
   25658           0 : SWIGINTERN PyObject *_wrap_layerObj_labelmaxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25659             :   PyObject *resultobj = 0;
   25660             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25661           0 :   void *argp1 = 0 ;
   25662             :   int res1 = 0 ;
   25663           0 :   PyObject * obj0 = 0 ;
   25664             :   double result;
   25665             :   
   25666           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelmaxscaledenom_get",&obj0)) SWIG_fail;
   25667           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25668           0 :   if (!SWIG_IsOK(res1)) {
   25669           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelmaxscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25670             :   }
   25671           0 :   arg1 = (struct layerObj *)(argp1);
   25672           0 :   result = (double) ((arg1)->labelmaxscaledenom);
   25673           0 :   resultobj = SWIG_From_double((double)(result));
   25674           0 :   return resultobj;
   25675           0 : fail:
   25676             :   return NULL;
   25677             : }
   25678             : 
   25679             : 
   25680           0 : SWIGINTERN PyObject *_wrap_layerObj_mingeowidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25681             :   PyObject *resultobj = 0;
   25682             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25683             :   double arg2 ;
   25684           0 :   void *argp1 = 0 ;
   25685             :   int res1 = 0 ;
   25686             :   double val2 ;
   25687             :   int ecode2 = 0 ;
   25688           0 :   PyObject * obj0 = 0 ;
   25689           0 :   PyObject * obj1 = 0 ;
   25690             :   
   25691           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_mingeowidth_set",&obj0,&obj1)) SWIG_fail;
   25692           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25693           0 :   if (!SWIG_IsOK(res1)) {
   25694           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mingeowidth_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25695             :   }
   25696           0 :   arg1 = (struct layerObj *)(argp1);
   25697           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25698           0 :   if (!SWIG_IsOK(ecode2)) {
   25699           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_mingeowidth_set" "', argument " "2"" of type '" "double""'");
   25700             :   } 
   25701           0 :   arg2 = (double)(val2);
   25702           0 :   if (arg1) (arg1)->mingeowidth = arg2;
   25703             :   resultobj = SWIG_Py_Void();
   25704           0 :   return resultobj;
   25705           0 : fail:
   25706             :   return NULL;
   25707             : }
   25708             : 
   25709             : 
   25710           0 : SWIGINTERN PyObject *_wrap_layerObj_mingeowidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25711             :   PyObject *resultobj = 0;
   25712             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25713           0 :   void *argp1 = 0 ;
   25714             :   int res1 = 0 ;
   25715           0 :   PyObject * obj0 = 0 ;
   25716             :   double result;
   25717             :   
   25718           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_mingeowidth_get",&obj0)) SWIG_fail;
   25719           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25720           0 :   if (!SWIG_IsOK(res1)) {
   25721           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mingeowidth_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25722             :   }
   25723           0 :   arg1 = (struct layerObj *)(argp1);
   25724           0 :   result = (double) ((arg1)->mingeowidth);
   25725           0 :   resultobj = SWIG_From_double((double)(result));
   25726           0 :   return resultobj;
   25727           0 : fail:
   25728             :   return NULL;
   25729             : }
   25730             : 
   25731             : 
   25732           0 : SWIGINTERN PyObject *_wrap_layerObj_maxgeowidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25733             :   PyObject *resultobj = 0;
   25734             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25735             :   double arg2 ;
   25736           0 :   void *argp1 = 0 ;
   25737             :   int res1 = 0 ;
   25738             :   double val2 ;
   25739             :   int ecode2 = 0 ;
   25740           0 :   PyObject * obj0 = 0 ;
   25741           0 :   PyObject * obj1 = 0 ;
   25742             :   
   25743           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_maxgeowidth_set",&obj0,&obj1)) SWIG_fail;
   25744           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25745           0 :   if (!SWIG_IsOK(res1)) {
   25746           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxgeowidth_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25747             :   }
   25748           0 :   arg1 = (struct layerObj *)(argp1);
   25749           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   25750           0 :   if (!SWIG_IsOK(ecode2)) {
   25751           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_maxgeowidth_set" "', argument " "2"" of type '" "double""'");
   25752             :   } 
   25753           0 :   arg2 = (double)(val2);
   25754           0 :   if (arg1) (arg1)->maxgeowidth = arg2;
   25755             :   resultobj = SWIG_Py_Void();
   25756           0 :   return resultobj;
   25757           0 : fail:
   25758             :   return NULL;
   25759             : }
   25760             : 
   25761             : 
   25762           0 : SWIGINTERN PyObject *_wrap_layerObj_maxgeowidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25763             :   PyObject *resultobj = 0;
   25764             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25765           0 :   void *argp1 = 0 ;
   25766             :   int res1 = 0 ;
   25767           0 :   PyObject * obj0 = 0 ;
   25768             :   double result;
   25769             :   
   25770           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxgeowidth_get",&obj0)) SWIG_fail;
   25771           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25772           0 :   if (!SWIG_IsOK(res1)) {
   25773           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxgeowidth_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25774             :   }
   25775           0 :   arg1 = (struct layerObj *)(argp1);
   25776           0 :   result = (double) ((arg1)->maxgeowidth);
   25777           0 :   resultobj = SWIG_From_double((double)(result));
   25778           0 :   return resultobj;
   25779           0 : fail:
   25780             :   return NULL;
   25781             : }
   25782             : 
   25783             : 
   25784           0 : SWIGINTERN PyObject *_wrap_layerObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25785             :   PyObject *resultobj = 0;
   25786             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25787             :   int arg2 ;
   25788           0 :   void *argp1 = 0 ;
   25789             :   int res1 = 0 ;
   25790             :   int val2 ;
   25791             :   int ecode2 = 0 ;
   25792           0 :   PyObject * obj0 = 0 ;
   25793           0 :   PyObject * obj1 = 0 ;
   25794             :   
   25795           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
   25796           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25797           0 :   if (!SWIG_IsOK(res1)) {
   25798           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_sizeunits_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25799             :   }
   25800           0 :   arg1 = (struct layerObj *)(argp1);
   25801           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25802           0 :   if (!SWIG_IsOK(ecode2)) {
   25803           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
   25804             :   } 
   25805             :   arg2 = (int)(val2);
   25806           0 :   if (arg1) (arg1)->sizeunits = arg2;
   25807             :   resultobj = SWIG_Py_Void();
   25808           0 :   return resultobj;
   25809           0 : fail:
   25810             :   return NULL;
   25811             : }
   25812             : 
   25813             : 
   25814           0 : SWIGINTERN PyObject *_wrap_layerObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25815             :   PyObject *resultobj = 0;
   25816             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25817           0 :   void *argp1 = 0 ;
   25818             :   int res1 = 0 ;
   25819           0 :   PyObject * obj0 = 0 ;
   25820             :   int result;
   25821             :   
   25822           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_sizeunits_get",&obj0)) SWIG_fail;
   25823           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25824           0 :   if (!SWIG_IsOK(res1)) {
   25825           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_sizeunits_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25826             :   }
   25827           0 :   arg1 = (struct layerObj *)(argp1);
   25828           0 :   result = (int) ((arg1)->sizeunits);
   25829             :   resultobj = SWIG_From_int((int)(result));
   25830           0 :   return resultobj;
   25831           0 : fail:
   25832             :   return NULL;
   25833             : }
   25834             : 
   25835             : 
   25836           0 : SWIGINTERN PyObject *_wrap_layerObj_maxfeatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25837             :   PyObject *resultobj = 0;
   25838             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25839             :   int arg2 ;
   25840           0 :   void *argp1 = 0 ;
   25841             :   int res1 = 0 ;
   25842             :   int val2 ;
   25843             :   int ecode2 = 0 ;
   25844           0 :   PyObject * obj0 = 0 ;
   25845           0 :   PyObject * obj1 = 0 ;
   25846             :   
   25847           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_maxfeatures_set",&obj0,&obj1)) SWIG_fail;
   25848           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25849           0 :   if (!SWIG_IsOK(res1)) {
   25850           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxfeatures_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25851             :   }
   25852           0 :   arg1 = (struct layerObj *)(argp1);
   25853           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25854           0 :   if (!SWIG_IsOK(ecode2)) {
   25855           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_maxfeatures_set" "', argument " "2"" of type '" "int""'");
   25856             :   } 
   25857             :   arg2 = (int)(val2);
   25858           0 :   if (arg1) (arg1)->maxfeatures = arg2;
   25859             :   resultobj = SWIG_Py_Void();
   25860           0 :   return resultobj;
   25861           0 : fail:
   25862             :   return NULL;
   25863             : }
   25864             : 
   25865             : 
   25866           0 : SWIGINTERN PyObject *_wrap_layerObj_maxfeatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25867             :   PyObject *resultobj = 0;
   25868             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25869           0 :   void *argp1 = 0 ;
   25870             :   int res1 = 0 ;
   25871           0 :   PyObject * obj0 = 0 ;
   25872             :   int result;
   25873             :   
   25874           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxfeatures_get",&obj0)) SWIG_fail;
   25875           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25876           0 :   if (!SWIG_IsOK(res1)) {
   25877           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxfeatures_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25878             :   }
   25879           0 :   arg1 = (struct layerObj *)(argp1);
   25880           0 :   result = (int) ((arg1)->maxfeatures);
   25881             :   resultobj = SWIG_From_int((int)(result));
   25882           0 :   return resultobj;
   25883           0 : fail:
   25884             :   return NULL;
   25885             : }
   25886             : 
   25887             : 
   25888           0 : SWIGINTERN PyObject *_wrap_layerObj_startindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25889             :   PyObject *resultobj = 0;
   25890             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25891             :   int arg2 ;
   25892           0 :   void *argp1 = 0 ;
   25893             :   int res1 = 0 ;
   25894             :   int val2 ;
   25895             :   int ecode2 = 0 ;
   25896           0 :   PyObject * obj0 = 0 ;
   25897           0 :   PyObject * obj1 = 0 ;
   25898             :   
   25899           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_startindex_set",&obj0,&obj1)) SWIG_fail;
   25900           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25901           0 :   if (!SWIG_IsOK(res1)) {
   25902           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_startindex_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25903             :   }
   25904           0 :   arg1 = (struct layerObj *)(argp1);
   25905           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   25906           0 :   if (!SWIG_IsOK(ecode2)) {
   25907           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_startindex_set" "', argument " "2"" of type '" "int""'");
   25908             :   } 
   25909             :   arg2 = (int)(val2);
   25910           0 :   if (arg1) (arg1)->startindex = arg2;
   25911             :   resultobj = SWIG_Py_Void();
   25912           0 :   return resultobj;
   25913           0 : fail:
   25914             :   return NULL;
   25915             : }
   25916             : 
   25917             : 
   25918           0 : SWIGINTERN PyObject *_wrap_layerObj_startindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25919             :   PyObject *resultobj = 0;
   25920             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25921           0 :   void *argp1 = 0 ;
   25922             :   int res1 = 0 ;
   25923           0 :   PyObject * obj0 = 0 ;
   25924             :   int result;
   25925             :   
   25926           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_startindex_get",&obj0)) SWIG_fail;
   25927           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25928           0 :   if (!SWIG_IsOK(res1)) {
   25929           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_startindex_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25930             :   }
   25931           0 :   arg1 = (struct layerObj *)(argp1);
   25932           0 :   result = (int) ((arg1)->startindex);
   25933             :   resultobj = SWIG_From_int((int)(result));
   25934           0 :   return resultobj;
   25935           0 : fail:
   25936             :   return NULL;
   25937             : }
   25938             : 
   25939             : 
   25940           0 : SWIGINTERN PyObject *_wrap_layerObj_offsite_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25941             :   PyObject *resultobj = 0;
   25942             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25943             :   colorObj *arg2 = (colorObj *) 0 ;
   25944           0 :   void *argp1 = 0 ;
   25945             :   int res1 = 0 ;
   25946           0 :   void *argp2 = 0 ;
   25947             :   int res2 = 0 ;
   25948           0 :   PyObject * obj0 = 0 ;
   25949           0 :   PyObject * obj1 = 0 ;
   25950             :   
   25951           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_offsite_set",&obj0,&obj1)) SWIG_fail;
   25952           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25953           0 :   if (!SWIG_IsOK(res1)) {
   25954           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_offsite_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25955             :   }
   25956           0 :   arg1 = (struct layerObj *)(argp1);
   25957           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   25958           0 :   if (!SWIG_IsOK(res2)) {
   25959           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_offsite_set" "', argument " "2"" of type '" "colorObj *""'"); 
   25960             :   }
   25961           0 :   arg2 = (colorObj *)(argp2);
   25962           0 :   if (arg1) (arg1)->offsite = *arg2;
   25963             :   resultobj = SWIG_Py_Void();
   25964           0 :   return resultobj;
   25965           0 : fail:
   25966             :   return NULL;
   25967             : }
   25968             : 
   25969             : 
   25970           0 : SWIGINTERN PyObject *_wrap_layerObj_offsite_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25971             :   PyObject *resultobj = 0;
   25972             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25973           0 :   void *argp1 = 0 ;
   25974             :   int res1 = 0 ;
   25975           0 :   PyObject * obj0 = 0 ;
   25976             :   colorObj *result = 0 ;
   25977             :   
   25978           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_offsite_get",&obj0)) SWIG_fail;
   25979           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   25980           0 :   if (!SWIG_IsOK(res1)) {
   25981           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_offsite_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   25982             :   }
   25983           0 :   arg1 = (struct layerObj *)(argp1);
   25984           0 :   result = (colorObj *)& ((arg1)->offsite);
   25985           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   25986           0 :   return resultobj;
   25987           0 : fail:
   25988             :   return NULL;
   25989             : }
   25990             : 
   25991             : 
   25992           0 : SWIGINTERN PyObject *_wrap_layerObj_transform_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   25993             :   PyObject *resultobj = 0;
   25994             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   25995             :   int arg2 ;
   25996           0 :   void *argp1 = 0 ;
   25997             :   int res1 = 0 ;
   25998             :   int val2 ;
   25999             :   int ecode2 = 0 ;
   26000           0 :   PyObject * obj0 = 0 ;
   26001           0 :   PyObject * obj1 = 0 ;
   26002             :   
   26003           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_transform_set",&obj0,&obj1)) SWIG_fail;
   26004           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26005           0 :   if (!SWIG_IsOK(res1)) {
   26006           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_transform_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26007             :   }
   26008           0 :   arg1 = (struct layerObj *)(argp1);
   26009           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   26010           0 :   if (!SWIG_IsOK(ecode2)) {
   26011           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_transform_set" "', argument " "2"" of type '" "int""'");
   26012             :   } 
   26013             :   arg2 = (int)(val2);
   26014           0 :   if (arg1) (arg1)->transform = arg2;
   26015             :   resultobj = SWIG_Py_Void();
   26016           0 :   return resultobj;
   26017           0 : fail:
   26018             :   return NULL;
   26019             : }
   26020             : 
   26021             : 
   26022           0 : SWIGINTERN PyObject *_wrap_layerObj_transform_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26023             :   PyObject *resultobj = 0;
   26024             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26025           0 :   void *argp1 = 0 ;
   26026             :   int res1 = 0 ;
   26027           0 :   PyObject * obj0 = 0 ;
   26028             :   int result;
   26029             :   
   26030           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_transform_get",&obj0)) SWIG_fail;
   26031           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26032           0 :   if (!SWIG_IsOK(res1)) {
   26033           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_transform_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26034             :   }
   26035           0 :   arg1 = (struct layerObj *)(argp1);
   26036           0 :   result = (int) ((arg1)->transform);
   26037             :   resultobj = SWIG_From_int((int)(result));
   26038           0 :   return resultobj;
   26039           0 : fail:
   26040             :   return NULL;
   26041             : }
   26042             : 
   26043             : 
   26044           0 : SWIGINTERN PyObject *_wrap_layerObj_labelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26045             :   PyObject *resultobj = 0;
   26046             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26047             :   int arg2 ;
   26048           0 :   void *argp1 = 0 ;
   26049             :   int res1 = 0 ;
   26050             :   int val2 ;
   26051             :   int ecode2 = 0 ;
   26052           0 :   PyObject * obj0 = 0 ;
   26053           0 :   PyObject * obj1 = 0 ;
   26054             :   
   26055           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelcache_set",&obj0,&obj1)) SWIG_fail;
   26056           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26057           0 :   if (!SWIG_IsOK(res1)) {
   26058           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelcache_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26059             :   }
   26060           0 :   arg1 = (struct layerObj *)(argp1);
   26061           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   26062           0 :   if (!SWIG_IsOK(ecode2)) {
   26063           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_labelcache_set" "', argument " "2"" of type '" "int""'");
   26064             :   } 
   26065             :   arg2 = (int)(val2);
   26066           0 :   if (arg1) (arg1)->labelcache = arg2;
   26067             :   resultobj = SWIG_Py_Void();
   26068           0 :   return resultobj;
   26069           0 : fail:
   26070             :   return NULL;
   26071             : }
   26072             : 
   26073             : 
   26074           0 : SWIGINTERN PyObject *_wrap_layerObj_labelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26075             :   PyObject *resultobj = 0;
   26076             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26077           0 :   void *argp1 = 0 ;
   26078             :   int res1 = 0 ;
   26079           0 :   PyObject * obj0 = 0 ;
   26080             :   int result;
   26081             :   
   26082           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelcache_get",&obj0)) SWIG_fail;
   26083           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26084           0 :   if (!SWIG_IsOK(res1)) {
   26085           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelcache_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26086             :   }
   26087           0 :   arg1 = (struct layerObj *)(argp1);
   26088           0 :   result = (int) ((arg1)->labelcache);
   26089             :   resultobj = SWIG_From_int((int)(result));
   26090           0 :   return resultobj;
   26091           0 : fail:
   26092             :   return NULL;
   26093             : }
   26094             : 
   26095             : 
   26096           0 : SWIGINTERN PyObject *_wrap_layerObj_postlabelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26097             :   PyObject *resultobj = 0;
   26098             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26099             :   int arg2 ;
   26100           0 :   void *argp1 = 0 ;
   26101             :   int res1 = 0 ;
   26102             :   int val2 ;
   26103             :   int ecode2 = 0 ;
   26104           0 :   PyObject * obj0 = 0 ;
   26105           0 :   PyObject * obj1 = 0 ;
   26106             :   
   26107           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_postlabelcache_set",&obj0,&obj1)) SWIG_fail;
   26108           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26109           0 :   if (!SWIG_IsOK(res1)) {
   26110           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_postlabelcache_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26111             :   }
   26112           0 :   arg1 = (struct layerObj *)(argp1);
   26113           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   26114           0 :   if (!SWIG_IsOK(ecode2)) {
   26115           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_postlabelcache_set" "', argument " "2"" of type '" "int""'");
   26116             :   } 
   26117             :   arg2 = (int)(val2);
   26118           0 :   if (arg1) (arg1)->postlabelcache = arg2;
   26119             :   resultobj = SWIG_Py_Void();
   26120           0 :   return resultobj;
   26121           0 : fail:
   26122             :   return NULL;
   26123             : }
   26124             : 
   26125             : 
   26126           0 : SWIGINTERN PyObject *_wrap_layerObj_postlabelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26127             :   PyObject *resultobj = 0;
   26128             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26129           0 :   void *argp1 = 0 ;
   26130             :   int res1 = 0 ;
   26131           0 :   PyObject * obj0 = 0 ;
   26132             :   int result;
   26133             :   
   26134           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_postlabelcache_get",&obj0)) SWIG_fail;
   26135           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26136           0 :   if (!SWIG_IsOK(res1)) {
   26137           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_postlabelcache_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26138             :   }
   26139           0 :   arg1 = (struct layerObj *)(argp1);
   26140           0 :   result = (int) ((arg1)->postlabelcache);
   26141             :   resultobj = SWIG_From_int((int)(result));
   26142           0 :   return resultobj;
   26143           0 : fail:
   26144             :   return NULL;
   26145             : }
   26146             : 
   26147             : 
   26148           0 : SWIGINTERN PyObject *_wrap_layerObj_labelitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26149             :   PyObject *resultobj = 0;
   26150             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26151             :   char *arg2 = (char *) 0 ;
   26152           0 :   void *argp1 = 0 ;
   26153             :   int res1 = 0 ;
   26154             :   int res2 ;
   26155           0 :   char *buf2 = 0 ;
   26156           0 :   int alloc2 = 0 ;
   26157           0 :   PyObject * obj0 = 0 ;
   26158           0 :   PyObject * obj1 = 0 ;
   26159             :   
   26160           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelitem_set",&obj0,&obj1)) SWIG_fail;
   26161           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26162           0 :   if (!SWIG_IsOK(res1)) {
   26163           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelitem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26164             :   }
   26165           0 :   arg1 = (struct layerObj *)(argp1);
   26166           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26167           0 :   if (!SWIG_IsOK(res2)) {
   26168           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_labelitem_set" "', argument " "2"" of type '" "char *""'");
   26169             :   }
   26170           0 :   arg2 = (char *)(buf2);
   26171             :   {
   26172           0 :     if (arg1->labelitem) free((char*)arg1->labelitem);
   26173           0 :     if (arg2) {
   26174           0 :       arg1->labelitem = (char *) malloc(strlen(arg2)+1);
   26175             :       strcpy((char*)arg1->labelitem,arg2);
   26176             :     } else {
   26177           0 :       arg1->labelitem = 0;
   26178             :     }
   26179             :   }
   26180             :   resultobj = SWIG_Py_Void();
   26181           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26182             :   return resultobj;
   26183           0 : fail:
   26184           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26185             :   return NULL;
   26186             : }
   26187             : 
   26188             : 
   26189           0 : SWIGINTERN PyObject *_wrap_layerObj_labelitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26190             :   PyObject *resultobj = 0;
   26191             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26192           0 :   void *argp1 = 0 ;
   26193             :   int res1 = 0 ;
   26194           0 :   PyObject * obj0 = 0 ;
   26195             :   char *result = 0 ;
   26196             :   
   26197           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelitem_get",&obj0)) SWIG_fail;
   26198           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26199           0 :   if (!SWIG_IsOK(res1)) {
   26200           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelitem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26201             :   }
   26202           0 :   arg1 = (struct layerObj *)(argp1);
   26203           0 :   result = (char *) ((arg1)->labelitem);
   26204           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26205           0 :   return resultobj;
   26206           0 : fail:
   26207             :   return NULL;
   26208             : }
   26209             : 
   26210             : 
   26211           0 : SWIGINTERN PyObject *_wrap_layerObj_tileitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26212             :   PyObject *resultobj = 0;
   26213             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26214             :   char *arg2 = (char *) 0 ;
   26215           0 :   void *argp1 = 0 ;
   26216             :   int res1 = 0 ;
   26217             :   int res2 ;
   26218           0 :   char *buf2 = 0 ;
   26219           0 :   int alloc2 = 0 ;
   26220           0 :   PyObject * obj0 = 0 ;
   26221           0 :   PyObject * obj1 = 0 ;
   26222             :   
   26223           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tileitem_set",&obj0,&obj1)) SWIG_fail;
   26224           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26225           0 :   if (!SWIG_IsOK(res1)) {
   26226           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileitem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26227             :   }
   26228           0 :   arg1 = (struct layerObj *)(argp1);
   26229           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26230           0 :   if (!SWIG_IsOK(res2)) {
   26231           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_tileitem_set" "', argument " "2"" of type '" "char *""'");
   26232             :   }
   26233           0 :   arg2 = (char *)(buf2);
   26234             :   {
   26235           0 :     if (arg1->tileitem) free((char*)arg1->tileitem);
   26236           0 :     if (arg2) {
   26237           0 :       arg1->tileitem = (char *) malloc(strlen(arg2)+1);
   26238             :       strcpy((char*)arg1->tileitem,arg2);
   26239             :     } else {
   26240           0 :       arg1->tileitem = 0;
   26241             :     }
   26242             :   }
   26243             :   resultobj = SWIG_Py_Void();
   26244           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26245             :   return resultobj;
   26246           0 : fail:
   26247           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26248             :   return NULL;
   26249             : }
   26250             : 
   26251             : 
   26252           0 : SWIGINTERN PyObject *_wrap_layerObj_tileitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26253             :   PyObject *resultobj = 0;
   26254             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26255           0 :   void *argp1 = 0 ;
   26256             :   int res1 = 0 ;
   26257           0 :   PyObject * obj0 = 0 ;
   26258             :   char *result = 0 ;
   26259             :   
   26260           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tileitem_get",&obj0)) SWIG_fail;
   26261           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26262           0 :   if (!SWIG_IsOK(res1)) {
   26263           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileitem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26264             :   }
   26265           0 :   arg1 = (struct layerObj *)(argp1);
   26266           0 :   result = (char *) ((arg1)->tileitem);
   26267           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26268           0 :   return resultobj;
   26269           0 : fail:
   26270             :   return NULL;
   26271             : }
   26272             : 
   26273             : 
   26274           0 : SWIGINTERN PyObject *_wrap_layerObj_tileindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26275             :   PyObject *resultobj = 0;
   26276             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26277             :   char *arg2 = (char *) 0 ;
   26278           0 :   void *argp1 = 0 ;
   26279             :   int res1 = 0 ;
   26280             :   int res2 ;
   26281           0 :   char *buf2 = 0 ;
   26282           0 :   int alloc2 = 0 ;
   26283           0 :   PyObject * obj0 = 0 ;
   26284           0 :   PyObject * obj1 = 0 ;
   26285             :   
   26286           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tileindex_set",&obj0,&obj1)) SWIG_fail;
   26287           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26288           0 :   if (!SWIG_IsOK(res1)) {
   26289           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileindex_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26290             :   }
   26291           0 :   arg1 = (struct layerObj *)(argp1);
   26292           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26293           0 :   if (!SWIG_IsOK(res2)) {
   26294           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_tileindex_set" "', argument " "2"" of type '" "char *""'");
   26295             :   }
   26296           0 :   arg2 = (char *)(buf2);
   26297             :   {
   26298           0 :     if (arg1->tileindex) free((char*)arg1->tileindex);
   26299           0 :     if (arg2) {
   26300           0 :       arg1->tileindex = (char *) malloc(strlen(arg2)+1);
   26301             :       strcpy((char*)arg1->tileindex,arg2);
   26302             :     } else {
   26303           0 :       arg1->tileindex = 0;
   26304             :     }
   26305             :   }
   26306             :   resultobj = SWIG_Py_Void();
   26307           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26308             :   return resultobj;
   26309           0 : fail:
   26310           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26311             :   return NULL;
   26312             : }
   26313             : 
   26314             : 
   26315           0 : SWIGINTERN PyObject *_wrap_layerObj_tileindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26316             :   PyObject *resultobj = 0;
   26317             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26318           0 :   void *argp1 = 0 ;
   26319             :   int res1 = 0 ;
   26320           0 :   PyObject * obj0 = 0 ;
   26321             :   char *result = 0 ;
   26322             :   
   26323           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tileindex_get",&obj0)) SWIG_fail;
   26324           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26325           0 :   if (!SWIG_IsOK(res1)) {
   26326           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileindex_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26327             :   }
   26328           0 :   arg1 = (struct layerObj *)(argp1);
   26329           0 :   result = (char *) ((arg1)->tileindex);
   26330           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26331           0 :   return resultobj;
   26332           0 : fail:
   26333             :   return NULL;
   26334             : }
   26335             : 
   26336             : 
   26337           0 : SWIGINTERN PyObject *_wrap_layerObj_tilesrs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26338             :   PyObject *resultobj = 0;
   26339             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26340             :   char *arg2 = (char *) 0 ;
   26341           0 :   void *argp1 = 0 ;
   26342             :   int res1 = 0 ;
   26343             :   int res2 ;
   26344           0 :   char *buf2 = 0 ;
   26345           0 :   int alloc2 = 0 ;
   26346           0 :   PyObject * obj0 = 0 ;
   26347           0 :   PyObject * obj1 = 0 ;
   26348             :   
   26349           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tilesrs_set",&obj0,&obj1)) SWIG_fail;
   26350           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26351           0 :   if (!SWIG_IsOK(res1)) {
   26352           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tilesrs_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26353             :   }
   26354           0 :   arg1 = (struct layerObj *)(argp1);
   26355           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26356           0 :   if (!SWIG_IsOK(res2)) {
   26357           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_tilesrs_set" "', argument " "2"" of type '" "char *""'");
   26358             :   }
   26359           0 :   arg2 = (char *)(buf2);
   26360             :   {
   26361           0 :     if (arg1->tilesrs) free((char*)arg1->tilesrs);
   26362           0 :     if (arg2) {
   26363           0 :       arg1->tilesrs = (char *) malloc(strlen(arg2)+1);
   26364             :       strcpy((char*)arg1->tilesrs,arg2);
   26365             :     } else {
   26366           0 :       arg1->tilesrs = 0;
   26367             :     }
   26368             :   }
   26369             :   resultobj = SWIG_Py_Void();
   26370           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26371             :   return resultobj;
   26372           0 : fail:
   26373           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26374             :   return NULL;
   26375             : }
   26376             : 
   26377             : 
   26378           0 : SWIGINTERN PyObject *_wrap_layerObj_tilesrs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26379             :   PyObject *resultobj = 0;
   26380             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26381           0 :   void *argp1 = 0 ;
   26382             :   int res1 = 0 ;
   26383           0 :   PyObject * obj0 = 0 ;
   26384             :   char *result = 0 ;
   26385             :   
   26386           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tilesrs_get",&obj0)) SWIG_fail;
   26387           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26388           0 :   if (!SWIG_IsOK(res1)) {
   26389           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tilesrs_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26390             :   }
   26391           0 :   arg1 = (struct layerObj *)(argp1);
   26392           0 :   result = (char *) ((arg1)->tilesrs);
   26393           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26394           0 :   return resultobj;
   26395           0 : fail:
   26396             :   return NULL;
   26397             : }
   26398             : 
   26399             : 
   26400           0 : SWIGINTERN PyObject *_wrap_layerObj_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26401             :   PyObject *resultobj = 0;
   26402             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26403             :   int arg2 ;
   26404           0 :   void *argp1 = 0 ;
   26405             :   int res1 = 0 ;
   26406             :   int val2 ;
   26407             :   int ecode2 = 0 ;
   26408           0 :   PyObject * obj0 = 0 ;
   26409           0 :   PyObject * obj1 = 0 ;
   26410             :   
   26411           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_units_set",&obj0,&obj1)) SWIG_fail;
   26412           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26413           0 :   if (!SWIG_IsOK(res1)) {
   26414           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_units_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26415             :   }
   26416           0 :   arg1 = (struct layerObj *)(argp1);
   26417           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   26418           0 :   if (!SWIG_IsOK(ecode2)) {
   26419           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_units_set" "', argument " "2"" of type '" "int""'");
   26420             :   } 
   26421             :   arg2 = (int)(val2);
   26422           0 :   if (arg1) (arg1)->units = arg2;
   26423             :   resultobj = SWIG_Py_Void();
   26424           0 :   return resultobj;
   26425           0 : fail:
   26426             :   return NULL;
   26427             : }
   26428             : 
   26429             : 
   26430           0 : SWIGINTERN PyObject *_wrap_layerObj_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26431             :   PyObject *resultobj = 0;
   26432             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26433           0 :   void *argp1 = 0 ;
   26434             :   int res1 = 0 ;
   26435           0 :   PyObject * obj0 = 0 ;
   26436             :   int result;
   26437             :   
   26438           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_units_get",&obj0)) SWIG_fail;
   26439           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26440           0 :   if (!SWIG_IsOK(res1)) {
   26441           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_units_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26442             :   }
   26443           0 :   arg1 = (struct layerObj *)(argp1);
   26444           0 :   result = (int) ((arg1)->units);
   26445             :   resultobj = SWIG_From_int((int)(result));
   26446           0 :   return resultobj;
   26447           0 : fail:
   26448             :   return NULL;
   26449             : }
   26450             : 
   26451             : 
   26452           1 : SWIGINTERN PyObject *_wrap_layerObj_connection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26453             :   PyObject *resultobj = 0;
   26454             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26455             :   char *arg2 = (char *) 0 ;
   26456           1 :   void *argp1 = 0 ;
   26457             :   int res1 = 0 ;
   26458             :   int res2 ;
   26459           1 :   char *buf2 = 0 ;
   26460           1 :   int alloc2 = 0 ;
   26461           1 :   PyObject * obj0 = 0 ;
   26462           1 :   PyObject * obj1 = 0 ;
   26463             :   
   26464           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_connection_set",&obj0,&obj1)) SWIG_fail;
   26465           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26466           1 :   if (!SWIG_IsOK(res1)) {
   26467           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connection_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26468             :   }
   26469           1 :   arg1 = (struct layerObj *)(argp1);
   26470           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26471           1 :   if (!SWIG_IsOK(res2)) {
   26472           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_connection_set" "', argument " "2"" of type '" "char *""'");
   26473             :   }
   26474           1 :   arg2 = (char *)(buf2);
   26475             :   {
   26476           1 :     if (arg1->connection) free((char*)arg1->connection);
   26477           1 :     if (arg2) {
   26478           1 :       arg1->connection = (char *) malloc(strlen(arg2)+1);
   26479             :       strcpy((char*)arg1->connection,arg2);
   26480             :     } else {
   26481           0 :       arg1->connection = 0;
   26482             :     }
   26483             :   }
   26484             :   resultobj = SWIG_Py_Void();
   26485           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26486             :   return resultobj;
   26487           0 : fail:
   26488           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26489             :   return NULL;
   26490             : }
   26491             : 
   26492             : 
   26493           0 : SWIGINTERN PyObject *_wrap_layerObj_connection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26494             :   PyObject *resultobj = 0;
   26495             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26496           0 :   void *argp1 = 0 ;
   26497             :   int res1 = 0 ;
   26498           0 :   PyObject * obj0 = 0 ;
   26499             :   char *result = 0 ;
   26500             :   
   26501           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_connection_get",&obj0)) SWIG_fail;
   26502           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26503           0 :   if (!SWIG_IsOK(res1)) {
   26504           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connection_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26505             :   }
   26506           0 :   arg1 = (struct layerObj *)(argp1);
   26507           0 :   result = (char *) ((arg1)->connection);
   26508           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26509           0 :   return resultobj;
   26510           0 : fail:
   26511             :   return NULL;
   26512             : }
   26513             : 
   26514             : 
   26515           0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26516             :   PyObject *resultobj = 0;
   26517             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26518             :   char *arg2 = (char *) 0 ;
   26519           0 :   void *argp1 = 0 ;
   26520             :   int res1 = 0 ;
   26521             :   int res2 ;
   26522           0 :   char *buf2 = 0 ;
   26523           0 :   int alloc2 = 0 ;
   26524           0 :   PyObject * obj0 = 0 ;
   26525           0 :   PyObject * obj1 = 0 ;
   26526             :   
   26527           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_plugin_library_set",&obj0,&obj1)) SWIG_fail;
   26528           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26529           0 :   if (!SWIG_IsOK(res1)) {
   26530           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26531             :   }
   26532           0 :   arg1 = (struct layerObj *)(argp1);
   26533           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26534           0 :   if (!SWIG_IsOK(res2)) {
   26535           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_plugin_library_set" "', argument " "2"" of type '" "char *""'");
   26536             :   }
   26537           0 :   arg2 = (char *)(buf2);
   26538             :   {
   26539           0 :     if (arg1->plugin_library) free((char*)arg1->plugin_library);
   26540           0 :     if (arg2) {
   26541           0 :       arg1->plugin_library = (char *) malloc(strlen(arg2)+1);
   26542             :       strcpy((char*)arg1->plugin_library,arg2);
   26543             :     } else {
   26544           0 :       arg1->plugin_library = 0;
   26545             :     }
   26546             :   }
   26547             :   resultobj = SWIG_Py_Void();
   26548           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26549             :   return resultobj;
   26550           0 : fail:
   26551           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26552             :   return NULL;
   26553             : }
   26554             : 
   26555             : 
   26556           0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26557             :   PyObject *resultobj = 0;
   26558             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26559           0 :   void *argp1 = 0 ;
   26560             :   int res1 = 0 ;
   26561           0 :   PyObject * obj0 = 0 ;
   26562             :   char *result = 0 ;
   26563             :   
   26564           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_plugin_library_get",&obj0)) SWIG_fail;
   26565           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26566           0 :   if (!SWIG_IsOK(res1)) {
   26567           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26568             :   }
   26569           0 :   arg1 = (struct layerObj *)(argp1);
   26570           0 :   result = (char *) ((arg1)->plugin_library);
   26571           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26572           0 :   return resultobj;
   26573           0 : fail:
   26574             :   return NULL;
   26575             : }
   26576             : 
   26577             : 
   26578           0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_original_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26579             :   PyObject *resultobj = 0;
   26580             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26581             :   char *arg2 = (char *) 0 ;
   26582           0 :   void *argp1 = 0 ;
   26583             :   int res1 = 0 ;
   26584             :   int res2 ;
   26585           0 :   char *buf2 = 0 ;
   26586           0 :   int alloc2 = 0 ;
   26587           0 :   PyObject * obj0 = 0 ;
   26588           0 :   PyObject * obj1 = 0 ;
   26589             :   
   26590           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_plugin_library_original_set",&obj0,&obj1)) SWIG_fail;
   26591           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26592           0 :   if (!SWIG_IsOK(res1)) {
   26593           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_original_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26594             :   }
   26595           0 :   arg1 = (struct layerObj *)(argp1);
   26596           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26597           0 :   if (!SWIG_IsOK(res2)) {
   26598           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_plugin_library_original_set" "', argument " "2"" of type '" "char *""'");
   26599             :   }
   26600           0 :   arg2 = (char *)(buf2);
   26601             :   {
   26602           0 :     if (arg1->plugin_library_original) free((char*)arg1->plugin_library_original);
   26603           0 :     if (arg2) {
   26604           0 :       arg1->plugin_library_original = (char *) malloc(strlen(arg2)+1);
   26605             :       strcpy((char*)arg1->plugin_library_original,arg2);
   26606             :     } else {
   26607           0 :       arg1->plugin_library_original = 0;
   26608             :     }
   26609             :   }
   26610             :   resultobj = SWIG_Py_Void();
   26611           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26612             :   return resultobj;
   26613           0 : fail:
   26614           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26615             :   return NULL;
   26616             : }
   26617             : 
   26618             : 
   26619           0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_original_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26620             :   PyObject *resultobj = 0;
   26621             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26622           0 :   void *argp1 = 0 ;
   26623             :   int res1 = 0 ;
   26624           0 :   PyObject * obj0 = 0 ;
   26625             :   char *result = 0 ;
   26626             :   
   26627           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_plugin_library_original_get",&obj0)) SWIG_fail;
   26628           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26629           0 :   if (!SWIG_IsOK(res1)) {
   26630           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_original_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26631             :   }
   26632           0 :   arg1 = (struct layerObj *)(argp1);
   26633           0 :   result = (char *) ((arg1)->plugin_library_original);
   26634           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26635           0 :   return resultobj;
   26636           0 : fail:
   26637             :   return NULL;
   26638             : }
   26639             : 
   26640             : 
   26641           1 : SWIGINTERN PyObject *_wrap_layerObj_connectiontype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26642             :   PyObject *resultobj = 0;
   26643             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26644             :   enum MS_CONNECTION_TYPE arg2 ;
   26645           1 :   void *argp1 = 0 ;
   26646             :   int res1 = 0 ;
   26647             :   int val2 ;
   26648             :   int ecode2 = 0 ;
   26649           1 :   PyObject * obj0 = 0 ;
   26650           1 :   PyObject * obj1 = 0 ;
   26651             :   
   26652           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_connectiontype_set",&obj0,&obj1)) SWIG_fail;
   26653           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26654           1 :   if (!SWIG_IsOK(res1)) {
   26655           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectiontype_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26656             :   }
   26657           1 :   arg1 = (struct layerObj *)(argp1);
   26658           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   26659           1 :   if (!SWIG_IsOK(ecode2)) {
   26660           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_connectiontype_set" "', argument " "2"" of type '" "enum MS_CONNECTION_TYPE""'");
   26661             :   } 
   26662           1 :   arg2 = (enum MS_CONNECTION_TYPE)(val2);
   26663           1 :   if (arg1) (arg1)->connectiontype = arg2;
   26664             :   resultobj = SWIG_Py_Void();
   26665           1 :   return resultobj;
   26666           0 : fail:
   26667             :   return NULL;
   26668             : }
   26669             : 
   26670             : 
   26671           1 : SWIGINTERN PyObject *_wrap_layerObj_connectiontype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26672             :   PyObject *resultobj = 0;
   26673             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26674           1 :   void *argp1 = 0 ;
   26675             :   int res1 = 0 ;
   26676           1 :   PyObject * obj0 = 0 ;
   26677             :   enum MS_CONNECTION_TYPE result;
   26678             :   
   26679           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_connectiontype_get",&obj0)) SWIG_fail;
   26680           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26681           1 :   if (!SWIG_IsOK(res1)) {
   26682           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectiontype_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26683             :   }
   26684           1 :   arg1 = (struct layerObj *)(argp1);
   26685           1 :   result = (enum MS_CONNECTION_TYPE) ((arg1)->connectiontype);
   26686           1 :   resultobj = SWIG_From_int((int)(result));
   26687           1 :   return resultobj;
   26688           0 : fail:
   26689             :   return NULL;
   26690             : }
   26691             : 
   26692             : 
   26693           1 : SWIGINTERN PyObject *_wrap_layerObj_numitems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26694             :   PyObject *resultobj = 0;
   26695             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26696           1 :   void *argp1 = 0 ;
   26697             :   int res1 = 0 ;
   26698           1 :   PyObject * obj0 = 0 ;
   26699             :   int result;
   26700             :   
   26701           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numitems_get",&obj0)) SWIG_fail;
   26702           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26703           1 :   if (!SWIG_IsOK(res1)) {
   26704           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numitems_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26705             :   }
   26706           1 :   arg1 = (struct layerObj *)(argp1);
   26707           1 :   result = (int) ((arg1)->numitems);
   26708             :   resultobj = SWIG_From_int((int)(result));
   26709           1 :   return resultobj;
   26710           0 : fail:
   26711             :   return NULL;
   26712             : }
   26713             : 
   26714             : 
   26715           0 : SWIGINTERN PyObject *_wrap_layerObj_bandsitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26716             :   PyObject *resultobj = 0;
   26717             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26718             :   char *arg2 = (char *) 0 ;
   26719           0 :   void *argp1 = 0 ;
   26720             :   int res1 = 0 ;
   26721             :   int res2 ;
   26722           0 :   char *buf2 = 0 ;
   26723           0 :   int alloc2 = 0 ;
   26724           0 :   PyObject * obj0 = 0 ;
   26725           0 :   PyObject * obj1 = 0 ;
   26726             :   
   26727           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_bandsitem_set",&obj0,&obj1)) SWIG_fail;
   26728           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26729           0 :   if (!SWIG_IsOK(res1)) {
   26730           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_bandsitem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26731             :   }
   26732           0 :   arg1 = (struct layerObj *)(argp1);
   26733           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26734           0 :   if (!SWIG_IsOK(res2)) {
   26735           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_bandsitem_set" "', argument " "2"" of type '" "char *""'");
   26736             :   }
   26737           0 :   arg2 = (char *)(buf2);
   26738             :   {
   26739           0 :     if (arg1->bandsitem) free((char*)arg1->bandsitem);
   26740           0 :     if (arg2) {
   26741           0 :       arg1->bandsitem = (char *) malloc(strlen(arg2)+1);
   26742             :       strcpy((char*)arg1->bandsitem,arg2);
   26743             :     } else {
   26744           0 :       arg1->bandsitem = 0;
   26745             :     }
   26746             :   }
   26747             :   resultobj = SWIG_Py_Void();
   26748           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26749             :   return resultobj;
   26750           0 : fail:
   26751           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26752             :   return NULL;
   26753             : }
   26754             : 
   26755             : 
   26756           0 : SWIGINTERN PyObject *_wrap_layerObj_bandsitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26757             :   PyObject *resultobj = 0;
   26758             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26759           0 :   void *argp1 = 0 ;
   26760             :   int res1 = 0 ;
   26761           0 :   PyObject * obj0 = 0 ;
   26762             :   char *result = 0 ;
   26763             :   
   26764           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_bandsitem_get",&obj0)) SWIG_fail;
   26765           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26766           0 :   if (!SWIG_IsOK(res1)) {
   26767           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_bandsitem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26768             :   }
   26769           0 :   arg1 = (struct layerObj *)(argp1);
   26770           0 :   result = (char *) ((arg1)->bandsitem);
   26771           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26772           0 :   return resultobj;
   26773           0 : fail:
   26774             :   return NULL;
   26775             : }
   26776             : 
   26777             : 
   26778           1 : SWIGINTERN PyObject *_wrap_layerObj_filteritem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26779             :   PyObject *resultobj = 0;
   26780             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26781             :   char *arg2 = (char *) 0 ;
   26782           1 :   void *argp1 = 0 ;
   26783             :   int res1 = 0 ;
   26784             :   int res2 ;
   26785           1 :   char *buf2 = 0 ;
   26786           1 :   int alloc2 = 0 ;
   26787           1 :   PyObject * obj0 = 0 ;
   26788           1 :   PyObject * obj1 = 0 ;
   26789             :   
   26790           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_filteritem_set",&obj0,&obj1)) SWIG_fail;
   26791           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26792           1 :   if (!SWIG_IsOK(res1)) {
   26793           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_filteritem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26794             :   }
   26795           1 :   arg1 = (struct layerObj *)(argp1);
   26796           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26797           1 :   if (!SWIG_IsOK(res2)) {
   26798           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_filteritem_set" "', argument " "2"" of type '" "char *""'");
   26799             :   }
   26800           1 :   arg2 = (char *)(buf2);
   26801             :   {
   26802           1 :     if (arg1->filteritem) free((char*)arg1->filteritem);
   26803           1 :     if (arg2) {
   26804           1 :       arg1->filteritem = (char *) malloc(strlen(arg2)+1);
   26805             :       strcpy((char*)arg1->filteritem,arg2);
   26806             :     } else {
   26807           0 :       arg1->filteritem = 0;
   26808             :     }
   26809             :   }
   26810             :   resultobj = SWIG_Py_Void();
   26811           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26812             :   return resultobj;
   26813           0 : fail:
   26814           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26815             :   return NULL;
   26816             : }
   26817             : 
   26818             : 
   26819           0 : SWIGINTERN PyObject *_wrap_layerObj_filteritem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26820             :   PyObject *resultobj = 0;
   26821             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26822           0 :   void *argp1 = 0 ;
   26823             :   int res1 = 0 ;
   26824           0 :   PyObject * obj0 = 0 ;
   26825             :   char *result = 0 ;
   26826             :   
   26827           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_filteritem_get",&obj0)) SWIG_fail;
   26828           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26829           0 :   if (!SWIG_IsOK(res1)) {
   26830           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_filteritem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26831             :   }
   26832           0 :   arg1 = (struct layerObj *)(argp1);
   26833           0 :   result = (char *) ((arg1)->filteritem);
   26834           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26835           0 :   return resultobj;
   26836           0 : fail:
   26837             :   return NULL;
   26838             : }
   26839             : 
   26840             : 
   26841           0 : SWIGINTERN PyObject *_wrap_layerObj_styleitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26842             :   PyObject *resultobj = 0;
   26843             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26844             :   char *arg2 = (char *) 0 ;
   26845           0 :   void *argp1 = 0 ;
   26846             :   int res1 = 0 ;
   26847             :   int res2 ;
   26848           0 :   char *buf2 = 0 ;
   26849           0 :   int alloc2 = 0 ;
   26850           0 :   PyObject * obj0 = 0 ;
   26851           0 :   PyObject * obj1 = 0 ;
   26852             :   
   26853           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_styleitem_set",&obj0,&obj1)) SWIG_fail;
   26854           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26855           0 :   if (!SWIG_IsOK(res1)) {
   26856           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_styleitem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26857             :   }
   26858           0 :   arg1 = (struct layerObj *)(argp1);
   26859           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26860           0 :   if (!SWIG_IsOK(res2)) {
   26861           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_styleitem_set" "', argument " "2"" of type '" "char *""'");
   26862             :   }
   26863           0 :   arg2 = (char *)(buf2);
   26864             :   {
   26865           0 :     if (arg1->styleitem) free((char*)arg1->styleitem);
   26866           0 :     if (arg2) {
   26867           0 :       arg1->styleitem = (char *) malloc(strlen(arg2)+1);
   26868             :       strcpy((char*)arg1->styleitem,arg2);
   26869             :     } else {
   26870           0 :       arg1->styleitem = 0;
   26871             :     }
   26872             :   }
   26873             :   resultobj = SWIG_Py_Void();
   26874           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26875             :   return resultobj;
   26876           0 : fail:
   26877           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26878             :   return NULL;
   26879             : }
   26880             : 
   26881             : 
   26882           0 : SWIGINTERN PyObject *_wrap_layerObj_styleitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26883             :   PyObject *resultobj = 0;
   26884             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26885           0 :   void *argp1 = 0 ;
   26886             :   int res1 = 0 ;
   26887           0 :   PyObject * obj0 = 0 ;
   26888             :   char *result = 0 ;
   26889             :   
   26890           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_styleitem_get",&obj0)) SWIG_fail;
   26891           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26892           0 :   if (!SWIG_IsOK(res1)) {
   26893           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_styleitem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26894             :   }
   26895           0 :   arg1 = (struct layerObj *)(argp1);
   26896           0 :   result = (char *) ((arg1)->styleitem);
   26897           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26898           0 :   return resultobj;
   26899           0 : fail:
   26900             :   return NULL;
   26901             : }
   26902             : 
   26903             : 
   26904           0 : SWIGINTERN PyObject *_wrap_layerObj_requires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26905             :   PyObject *resultobj = 0;
   26906             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26907             :   char *arg2 = (char *) 0 ;
   26908           0 :   void *argp1 = 0 ;
   26909             :   int res1 = 0 ;
   26910             :   int res2 ;
   26911           0 :   char *buf2 = 0 ;
   26912           0 :   int alloc2 = 0 ;
   26913           0 :   PyObject * obj0 = 0 ;
   26914           0 :   PyObject * obj1 = 0 ;
   26915             :   
   26916           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_requires_set",&obj0,&obj1)) SWIG_fail;
   26917           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26918           0 :   if (!SWIG_IsOK(res1)) {
   26919           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_requires_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26920             :   }
   26921           0 :   arg1 = (struct layerObj *)(argp1);
   26922           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26923           0 :   if (!SWIG_IsOK(res2)) {
   26924           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_requires_set" "', argument " "2"" of type '" "char *""'");
   26925             :   }
   26926           0 :   arg2 = (char *)(buf2);
   26927             :   {
   26928           0 :     if (arg1->requires) free((char*)arg1->requires);
   26929           0 :     if (arg2) {
   26930           0 :       arg1->requires = (char *) malloc(strlen(arg2)+1);
   26931             :       strcpy((char*)arg1->requires,arg2);
   26932             :     } else {
   26933           0 :       arg1->requires = 0;
   26934             :     }
   26935             :   }
   26936             :   resultobj = SWIG_Py_Void();
   26937           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26938             :   return resultobj;
   26939           0 : fail:
   26940           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   26941             :   return NULL;
   26942             : }
   26943             : 
   26944             : 
   26945           0 : SWIGINTERN PyObject *_wrap_layerObj_requires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26946             :   PyObject *resultobj = 0;
   26947             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26948           0 :   void *argp1 = 0 ;
   26949             :   int res1 = 0 ;
   26950           0 :   PyObject * obj0 = 0 ;
   26951             :   char *result = 0 ;
   26952             :   
   26953           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_requires_get",&obj0)) SWIG_fail;
   26954           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26955           0 :   if (!SWIG_IsOK(res1)) {
   26956           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_requires_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26957             :   }
   26958           0 :   arg1 = (struct layerObj *)(argp1);
   26959           0 :   result = (char *) ((arg1)->requires);
   26960           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   26961           0 :   return resultobj;
   26962           0 : fail:
   26963             :   return NULL;
   26964             : }
   26965             : 
   26966             : 
   26967           0 : SWIGINTERN PyObject *_wrap_layerObj_labelrequires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   26968             :   PyObject *resultobj = 0;
   26969             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   26970             :   char *arg2 = (char *) 0 ;
   26971           0 :   void *argp1 = 0 ;
   26972             :   int res1 = 0 ;
   26973             :   int res2 ;
   26974           0 :   char *buf2 = 0 ;
   26975           0 :   int alloc2 = 0 ;
   26976           0 :   PyObject * obj0 = 0 ;
   26977           0 :   PyObject * obj1 = 0 ;
   26978             :   
   26979           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelrequires_set",&obj0,&obj1)) SWIG_fail;
   26980           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   26981           0 :   if (!SWIG_IsOK(res1)) {
   26982           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelrequires_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   26983             :   }
   26984           0 :   arg1 = (struct layerObj *)(argp1);
   26985           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   26986           0 :   if (!SWIG_IsOK(res2)) {
   26987           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_labelrequires_set" "', argument " "2"" of type '" "char *""'");
   26988             :   }
   26989           0 :   arg2 = (char *)(buf2);
   26990             :   {
   26991           0 :     if (arg1->labelrequires) free((char*)arg1->labelrequires);
   26992           0 :     if (arg2) {
   26993           0 :       arg1->labelrequires = (char *) malloc(strlen(arg2)+1);
   26994             :       strcpy((char*)arg1->labelrequires,arg2);
   26995             :     } else {
   26996           0 :       arg1->labelrequires = 0;
   26997             :     }
   26998             :   }
   26999             :   resultobj = SWIG_Py_Void();
   27000           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27001             :   return resultobj;
   27002           0 : fail:
   27003           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27004             :   return NULL;
   27005             : }
   27006             : 
   27007             : 
   27008           0 : SWIGINTERN PyObject *_wrap_layerObj_labelrequires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27009             :   PyObject *resultobj = 0;
   27010             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27011           0 :   void *argp1 = 0 ;
   27012             :   int res1 = 0 ;
   27013           0 :   PyObject * obj0 = 0 ;
   27014             :   char *result = 0 ;
   27015             :   
   27016           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelrequires_get",&obj0)) SWIG_fail;
   27017           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27018           0 :   if (!SWIG_IsOK(res1)) {
   27019           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelrequires_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27020             :   }
   27021           0 :   arg1 = (struct layerObj *)(argp1);
   27022           0 :   result = (char *) ((arg1)->labelrequires);
   27023           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   27024           0 :   return resultobj;
   27025           0 : fail:
   27026             :   return NULL;
   27027             : }
   27028             : 
   27029             : 
   27030           1 : SWIGINTERN PyObject *_wrap_layerObj_metadata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27031             :   PyObject *resultobj = 0;
   27032             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27033           1 :   void *argp1 = 0 ;
   27034             :   int res1 = 0 ;
   27035           1 :   PyObject * obj0 = 0 ;
   27036             :   hashTableObj *result = 0 ;
   27037             :   
   27038           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_metadata_get",&obj0)) SWIG_fail;
   27039           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27040           1 :   if (!SWIG_IsOK(res1)) {
   27041           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_metadata_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27042             :   }
   27043           1 :   arg1 = (struct layerObj *)(argp1);
   27044           1 :   result = (hashTableObj *)& ((arg1)->metadata);
   27045           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   27046           1 :   return resultobj;
   27047           0 : fail:
   27048             :   return NULL;
   27049             : }
   27050             : 
   27051             : 
   27052           0 : SWIGINTERN PyObject *_wrap_layerObj_validation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27053             :   PyObject *resultobj = 0;
   27054             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27055           0 :   void *argp1 = 0 ;
   27056             :   int res1 = 0 ;
   27057           0 :   PyObject * obj0 = 0 ;
   27058             :   hashTableObj *result = 0 ;
   27059             :   
   27060           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_validation_get",&obj0)) SWIG_fail;
   27061           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27062           0 :   if (!SWIG_IsOK(res1)) {
   27063           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_validation_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27064             :   }
   27065           0 :   arg1 = (struct layerObj *)(argp1);
   27066           0 :   result = (hashTableObj *)& ((arg1)->validation);
   27067           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   27068           0 :   return resultobj;
   27069           0 : fail:
   27070             :   return NULL;
   27071             : }
   27072             : 
   27073             : 
   27074           0 : SWIGINTERN PyObject *_wrap_layerObj_bindvals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27075             :   PyObject *resultobj = 0;
   27076             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27077           0 :   void *argp1 = 0 ;
   27078             :   int res1 = 0 ;
   27079           0 :   PyObject * obj0 = 0 ;
   27080             :   hashTableObj *result = 0 ;
   27081             :   
   27082           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_bindvals_get",&obj0)) SWIG_fail;
   27083           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27084           0 :   if (!SWIG_IsOK(res1)) {
   27085           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_bindvals_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27086             :   }
   27087           0 :   arg1 = (struct layerObj *)(argp1);
   27088           0 :   result = (hashTableObj *)& ((arg1)->bindvals);
   27089           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   27090           0 :   return resultobj;
   27091           0 : fail:
   27092             :   return NULL;
   27093             : }
   27094             : 
   27095             : 
   27096           0 : SWIGINTERN PyObject *_wrap_layerObj_cluster_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27097             :   PyObject *resultobj = 0;
   27098             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27099           0 :   void *argp1 = 0 ;
   27100             :   int res1 = 0 ;
   27101           0 :   PyObject * obj0 = 0 ;
   27102             :   clusterObj *result = 0 ;
   27103             :   
   27104           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_cluster_get",&obj0)) SWIG_fail;
   27105           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27106           0 :   if (!SWIG_IsOK(res1)) {
   27107           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_cluster_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27108             :   }
   27109           0 :   arg1 = (struct layerObj *)(argp1);
   27110           0 :   result = (clusterObj *)& ((arg1)->cluster);
   27111           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_clusterObj, 0 |  0 );
   27112           0 :   return resultobj;
   27113           0 : fail:
   27114             :   return NULL;
   27115             : }
   27116             : 
   27117             : 
   27118           0 : SWIGINTERN PyObject *_wrap_layerObj_dump_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27119             :   PyObject *resultobj = 0;
   27120             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27121             :   int arg2 ;
   27122           0 :   void *argp1 = 0 ;
   27123             :   int res1 = 0 ;
   27124             :   int val2 ;
   27125             :   int ecode2 = 0 ;
   27126           0 :   PyObject * obj0 = 0 ;
   27127           0 :   PyObject * obj1 = 0 ;
   27128             :   
   27129           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_dump_set",&obj0,&obj1)) SWIG_fail;
   27130           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27131           0 :   if (!SWIG_IsOK(res1)) {
   27132           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_dump_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27133             :   }
   27134           0 :   arg1 = (struct layerObj *)(argp1);
   27135           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   27136           0 :   if (!SWIG_IsOK(ecode2)) {
   27137           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_dump_set" "', argument " "2"" of type '" "int""'");
   27138             :   } 
   27139             :   arg2 = (int)(val2);
   27140           0 :   if (arg1) (arg1)->dump = arg2;
   27141             :   resultobj = SWIG_Py_Void();
   27142           0 :   return resultobj;
   27143           0 : fail:
   27144             :   return NULL;
   27145             : }
   27146             : 
   27147             : 
   27148           0 : SWIGINTERN PyObject *_wrap_layerObj_dump_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27149             :   PyObject *resultobj = 0;
   27150             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27151           0 :   void *argp1 = 0 ;
   27152             :   int res1 = 0 ;
   27153           0 :   PyObject * obj0 = 0 ;
   27154             :   int result;
   27155             :   
   27156           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_dump_get",&obj0)) SWIG_fail;
   27157           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27158           0 :   if (!SWIG_IsOK(res1)) {
   27159           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_dump_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27160             :   }
   27161           0 :   arg1 = (struct layerObj *)(argp1);
   27162           0 :   result = (int) ((arg1)->dump);
   27163             :   resultobj = SWIG_From_int((int)(result));
   27164           0 :   return resultobj;
   27165           0 : fail:
   27166             :   return NULL;
   27167             : }
   27168             : 
   27169             : 
   27170           1 : SWIGINTERN PyObject *_wrap_layerObj_debug_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27171             :   PyObject *resultobj = 0;
   27172             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27173             :   int arg2 ;
   27174           1 :   void *argp1 = 0 ;
   27175             :   int res1 = 0 ;
   27176             :   int val2 ;
   27177             :   int ecode2 = 0 ;
   27178           1 :   PyObject * obj0 = 0 ;
   27179           1 :   PyObject * obj1 = 0 ;
   27180             :   
   27181           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_debug_set",&obj0,&obj1)) SWIG_fail;
   27182           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27183           1 :   if (!SWIG_IsOK(res1)) {
   27184           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_debug_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27185             :   }
   27186           1 :   arg1 = (struct layerObj *)(argp1);
   27187           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   27188           1 :   if (!SWIG_IsOK(ecode2)) {
   27189           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_debug_set" "', argument " "2"" of type '" "int""'");
   27190             :   } 
   27191             :   arg2 = (int)(val2);
   27192           1 :   if (arg1) (arg1)->debug = arg2;
   27193             :   resultobj = SWIG_Py_Void();
   27194           1 :   return resultobj;
   27195           0 : fail:
   27196             :   return NULL;
   27197             : }
   27198             : 
   27199             : 
   27200           0 : SWIGINTERN PyObject *_wrap_layerObj_debug_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27201             :   PyObject *resultobj = 0;
   27202             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27203           0 :   void *argp1 = 0 ;
   27204             :   int res1 = 0 ;
   27205           0 :   PyObject * obj0 = 0 ;
   27206             :   int result;
   27207             :   
   27208           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_debug_get",&obj0)) SWIG_fail;
   27209           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27210           0 :   if (!SWIG_IsOK(res1)) {
   27211           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_debug_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27212             :   }
   27213           0 :   arg1 = (struct layerObj *)(argp1);
   27214           0 :   result = (int) ((arg1)->debug);
   27215             :   resultobj = SWIG_From_int((int)(result));
   27216           0 :   return resultobj;
   27217           0 : fail:
   27218             :   return NULL;
   27219             : }
   27220             : 
   27221             : 
   27222           1 : SWIGINTERN PyObject *_wrap_layerObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27223             :   PyObject *resultobj = 0;
   27224             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27225           1 :   void *argp1 = 0 ;
   27226             :   int res1 = 0 ;
   27227           1 :   PyObject * obj0 = 0 ;
   27228             :   rectObj *result = 0 ;
   27229             :   
   27230           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_extent_get",&obj0)) SWIG_fail;
   27231           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27232           1 :   if (!SWIG_IsOK(res1)) {
   27233           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_extent_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27234             :   }
   27235           1 :   arg1 = (struct layerObj *)(argp1);
   27236           1 :   result = (rectObj *)& ((arg1)->extent);
   27237           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   27238           1 :   return resultobj;
   27239           0 : fail:
   27240             :   return NULL;
   27241             : }
   27242             : 
   27243             : 
   27244           1 : SWIGINTERN PyObject *_wrap_layerObj_numprocessing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27245             :   PyObject *resultobj = 0;
   27246             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27247           1 :   void *argp1 = 0 ;
   27248             :   int res1 = 0 ;
   27249           1 :   PyObject * obj0 = 0 ;
   27250             :   int result;
   27251             :   
   27252           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numprocessing_get",&obj0)) SWIG_fail;
   27253           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27254           1 :   if (!SWIG_IsOK(res1)) {
   27255           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numprocessing_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27256             :   }
   27257           1 :   arg1 = (struct layerObj *)(argp1);
   27258           1 :   result = (int) ((arg1)->numprocessing);
   27259             :   resultobj = SWIG_From_int((int)(result));
   27260           1 :   return resultobj;
   27261           0 : fail:
   27262             :   return NULL;
   27263             : }
   27264             : 
   27265             : 
   27266           0 : SWIGINTERN PyObject *_wrap_layerObj_numjoins_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27267             :   PyObject *resultobj = 0;
   27268             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27269           0 :   void *argp1 = 0 ;
   27270             :   int res1 = 0 ;
   27271           0 :   PyObject * obj0 = 0 ;
   27272             :   int result;
   27273             :   
   27274           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numjoins_get",&obj0)) SWIG_fail;
   27275           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27276           0 :   if (!SWIG_IsOK(res1)) {
   27277           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numjoins_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27278             :   }
   27279           0 :   arg1 = (struct layerObj *)(argp1);
   27280           0 :   result = (int) ((arg1)->numjoins);
   27281             :   resultobj = SWIG_From_int((int)(result));
   27282           0 :   return resultobj;
   27283           0 : fail:
   27284             :   return NULL;
   27285             : }
   27286             : 
   27287             : 
   27288           0 : SWIGINTERN PyObject *_wrap_layerObj_classgroup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27289             :   PyObject *resultobj = 0;
   27290             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27291             :   char *arg2 = (char *) 0 ;
   27292           0 :   void *argp1 = 0 ;
   27293             :   int res1 = 0 ;
   27294             :   int res2 ;
   27295           0 :   char *buf2 = 0 ;
   27296           0 :   int alloc2 = 0 ;
   27297           0 :   PyObject * obj0 = 0 ;
   27298           0 :   PyObject * obj1 = 0 ;
   27299             :   
   27300           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_classgroup_set",&obj0,&obj1)) SWIG_fail;
   27301           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27302           0 :   if (!SWIG_IsOK(res1)) {
   27303           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classgroup_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27304             :   }
   27305           0 :   arg1 = (struct layerObj *)(argp1);
   27306           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   27307           0 :   if (!SWIG_IsOK(res2)) {
   27308           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_classgroup_set" "', argument " "2"" of type '" "char *""'");
   27309             :   }
   27310           0 :   arg2 = (char *)(buf2);
   27311             :   {
   27312           0 :     if (arg1->classgroup) free((char*)arg1->classgroup);
   27313           0 :     if (arg2) {
   27314           0 :       arg1->classgroup = (char *) malloc(strlen(arg2)+1);
   27315             :       strcpy((char*)arg1->classgroup,arg2);
   27316             :     } else {
   27317           0 :       arg1->classgroup = 0;
   27318             :     }
   27319             :   }
   27320             :   resultobj = SWIG_Py_Void();
   27321           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27322             :   return resultobj;
   27323           0 : fail:
   27324           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27325             :   return NULL;
   27326             : }
   27327             : 
   27328             : 
   27329           0 : SWIGINTERN PyObject *_wrap_layerObj_classgroup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27330             :   PyObject *resultobj = 0;
   27331             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27332           0 :   void *argp1 = 0 ;
   27333             :   int res1 = 0 ;
   27334           0 :   PyObject * obj0 = 0 ;
   27335             :   char *result = 0 ;
   27336             :   
   27337           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_classgroup_get",&obj0)) SWIG_fail;
   27338           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27339           0 :   if (!SWIG_IsOK(res1)) {
   27340           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classgroup_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27341             :   }
   27342           0 :   arg1 = (struct layerObj *)(argp1);
   27343           0 :   result = (char *) ((arg1)->classgroup);
   27344           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   27345           0 :   return resultobj;
   27346           0 : fail:
   27347             :   return NULL;
   27348             : }
   27349             : 
   27350             : 
   27351           0 : SWIGINTERN PyObject *_wrap_layerObj_mask_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27352             :   PyObject *resultobj = 0;
   27353             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27354             :   char *arg2 = (char *) 0 ;
   27355           0 :   void *argp1 = 0 ;
   27356             :   int res1 = 0 ;
   27357             :   int res2 ;
   27358           0 :   char *buf2 = 0 ;
   27359           0 :   int alloc2 = 0 ;
   27360           0 :   PyObject * obj0 = 0 ;
   27361           0 :   PyObject * obj1 = 0 ;
   27362             :   
   27363           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_mask_set",&obj0,&obj1)) SWIG_fail;
   27364           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27365           0 :   if (!SWIG_IsOK(res1)) {
   27366           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mask_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27367             :   }
   27368           0 :   arg1 = (struct layerObj *)(argp1);
   27369           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   27370           0 :   if (!SWIG_IsOK(res2)) {
   27371           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_mask_set" "', argument " "2"" of type '" "char *""'");
   27372             :   }
   27373           0 :   arg2 = (char *)(buf2);
   27374             :   {
   27375           0 :     if (arg1->mask) free((char*)arg1->mask);
   27376           0 :     if (arg2) {
   27377           0 :       arg1->mask = (char *) malloc(strlen(arg2)+1);
   27378             :       strcpy((char*)arg1->mask,arg2);
   27379             :     } else {
   27380           0 :       arg1->mask = 0;
   27381             :     }
   27382             :   }
   27383             :   resultobj = SWIG_Py_Void();
   27384           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27385             :   return resultobj;
   27386           0 : fail:
   27387           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27388             :   return NULL;
   27389             : }
   27390             : 
   27391             : 
   27392           0 : SWIGINTERN PyObject *_wrap_layerObj_mask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27393             :   PyObject *resultobj = 0;
   27394             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27395           0 :   void *argp1 = 0 ;
   27396             :   int res1 = 0 ;
   27397           0 :   PyObject * obj0 = 0 ;
   27398             :   char *result = 0 ;
   27399             :   
   27400           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_mask_get",&obj0)) SWIG_fail;
   27401           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27402           0 :   if (!SWIG_IsOK(res1)) {
   27403           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mask_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27404             :   }
   27405           0 :   arg1 = (struct layerObj *)(argp1);
   27406           0 :   result = (char *) ((arg1)->mask);
   27407           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   27408           0 :   return resultobj;
   27409           0 : fail:
   27410             :   return NULL;
   27411             : }
   27412             : 
   27413             : 
   27414           0 : SWIGINTERN PyObject *_wrap_layerObj_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27415             :   PyObject *resultobj = 0;
   27416             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27417             :   char *arg2 = (char *) 0 ;
   27418           0 :   void *argp1 = 0 ;
   27419             :   int res1 = 0 ;
   27420             :   int res2 ;
   27421           0 :   char *buf2 = 0 ;
   27422           0 :   int alloc2 = 0 ;
   27423           0 :   PyObject * obj0 = 0 ;
   27424           0 :   PyObject * obj1 = 0 ;
   27425             :   
   27426           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_encoding_set",&obj0,&obj1)) SWIG_fail;
   27427           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27428           0 :   if (!SWIG_IsOK(res1)) {
   27429           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_encoding_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27430             :   }
   27431           0 :   arg1 = (struct layerObj *)(argp1);
   27432           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   27433           0 :   if (!SWIG_IsOK(res2)) {
   27434           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_encoding_set" "', argument " "2"" of type '" "char *""'");
   27435             :   }
   27436           0 :   arg2 = (char *)(buf2);
   27437             :   {
   27438           0 :     if (arg1->encoding) free((char*)arg1->encoding);
   27439           0 :     if (arg2) {
   27440           0 :       arg1->encoding = (char *) malloc(strlen(arg2)+1);
   27441             :       strcpy((char*)arg1->encoding,arg2);
   27442             :     } else {
   27443           0 :       arg1->encoding = 0;
   27444             :     }
   27445             :   }
   27446             :   resultobj = SWIG_Py_Void();
   27447           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27448             :   return resultobj;
   27449           0 : fail:
   27450           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27451             :   return NULL;
   27452             : }
   27453             : 
   27454             : 
   27455           0 : SWIGINTERN PyObject *_wrap_layerObj_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27456             :   PyObject *resultobj = 0;
   27457             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27458           0 :   void *argp1 = 0 ;
   27459             :   int res1 = 0 ;
   27460           0 :   PyObject * obj0 = 0 ;
   27461             :   char *result = 0 ;
   27462             :   
   27463           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_encoding_get",&obj0)) SWIG_fail;
   27464           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27465           0 :   if (!SWIG_IsOK(res1)) {
   27466           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_encoding_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27467             :   }
   27468           0 :   arg1 = (struct layerObj *)(argp1);
   27469           0 :   result = (char *) ((arg1)->encoding);
   27470           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   27471           0 :   return resultobj;
   27472           0 : fail:
   27473             :   return NULL;
   27474             : }
   27475             : 
   27476             : 
   27477           0 : SWIGINTERN PyObject *_wrap_layerObj_utfitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27478             :   PyObject *resultobj = 0;
   27479             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27480             :   char *arg2 = (char *) 0 ;
   27481           0 :   void *argp1 = 0 ;
   27482             :   int res1 = 0 ;
   27483             :   int res2 ;
   27484           0 :   char *buf2 = 0 ;
   27485           0 :   int alloc2 = 0 ;
   27486           0 :   PyObject * obj0 = 0 ;
   27487           0 :   PyObject * obj1 = 0 ;
   27488             :   
   27489           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_utfitem_set",&obj0,&obj1)) SWIG_fail;
   27490           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27491           0 :   if (!SWIG_IsOK(res1)) {
   27492           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitem_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27493             :   }
   27494           0 :   arg1 = (struct layerObj *)(argp1);
   27495           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   27496           0 :   if (!SWIG_IsOK(res2)) {
   27497           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_utfitem_set" "', argument " "2"" of type '" "char *""'");
   27498             :   }
   27499           0 :   arg2 = (char *)(buf2);
   27500             :   {
   27501           0 :     if (arg1->utfitem) free((char*)arg1->utfitem);
   27502           0 :     if (arg2) {
   27503           0 :       arg1->utfitem = (char *) malloc(strlen(arg2)+1);
   27504             :       strcpy((char*)arg1->utfitem,arg2);
   27505             :     } else {
   27506           0 :       arg1->utfitem = 0;
   27507             :     }
   27508             :   }
   27509             :   resultobj = SWIG_Py_Void();
   27510           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27511             :   return resultobj;
   27512           0 : fail:
   27513           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   27514             :   return NULL;
   27515             : }
   27516             : 
   27517             : 
   27518           0 : SWIGINTERN PyObject *_wrap_layerObj_utfitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27519             :   PyObject *resultobj = 0;
   27520             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27521           0 :   void *argp1 = 0 ;
   27522             :   int res1 = 0 ;
   27523           0 :   PyObject * obj0 = 0 ;
   27524             :   char *result = 0 ;
   27525             :   
   27526           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_utfitem_get",&obj0)) SWIG_fail;
   27527           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27528           0 :   if (!SWIG_IsOK(res1)) {
   27529           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitem_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27530             :   }
   27531           0 :   arg1 = (struct layerObj *)(argp1);
   27532           0 :   result = (char *) ((arg1)->utfitem);
   27533           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   27534           0 :   return resultobj;
   27535           0 : fail:
   27536             :   return NULL;
   27537             : }
   27538             : 
   27539             : 
   27540           0 : SWIGINTERN PyObject *_wrap_layerObj_utfitemindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27541             :   PyObject *resultobj = 0;
   27542             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27543             :   int arg2 ;
   27544           0 :   void *argp1 = 0 ;
   27545             :   int res1 = 0 ;
   27546             :   int val2 ;
   27547             :   int ecode2 = 0 ;
   27548           0 :   PyObject * obj0 = 0 ;
   27549           0 :   PyObject * obj1 = 0 ;
   27550             :   
   27551           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_utfitemindex_set",&obj0,&obj1)) SWIG_fail;
   27552           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27553           0 :   if (!SWIG_IsOK(res1)) {
   27554           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitemindex_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27555             :   }
   27556           0 :   arg1 = (struct layerObj *)(argp1);
   27557           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   27558           0 :   if (!SWIG_IsOK(ecode2)) {
   27559           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_utfitemindex_set" "', argument " "2"" of type '" "int""'");
   27560             :   } 
   27561             :   arg2 = (int)(val2);
   27562           0 :   if (arg1) (arg1)->utfitemindex = arg2;
   27563             :   resultobj = SWIG_Py_Void();
   27564           0 :   return resultobj;
   27565           0 : fail:
   27566             :   return NULL;
   27567             : }
   27568             : 
   27569             : 
   27570           0 : SWIGINTERN PyObject *_wrap_layerObj_utfitemindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27571             :   PyObject *resultobj = 0;
   27572             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27573           0 :   void *argp1 = 0 ;
   27574             :   int res1 = 0 ;
   27575           0 :   PyObject * obj0 = 0 ;
   27576             :   int result;
   27577             :   
   27578           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_utfitemindex_get",&obj0)) SWIG_fail;
   27579           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27580           0 :   if (!SWIG_IsOK(res1)) {
   27581           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitemindex_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27582             :   }
   27583           0 :   arg1 = (struct layerObj *)(argp1);
   27584           0 :   result = (int) ((arg1)->utfitemindex);
   27585             :   resultobj = SWIG_From_int((int)(result));
   27586           0 :   return resultobj;
   27587           0 : fail:
   27588             :   return NULL;
   27589             : }
   27590             : 
   27591             : 
   27592           0 : SWIGINTERN PyObject *_wrap_layerObj_utfdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27593             :   PyObject *resultobj = 0;
   27594             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27595             :   expressionObj arg2 ;
   27596           0 :   void *argp1 = 0 ;
   27597             :   int res1 = 0 ;
   27598             :   void *argp2 ;
   27599             :   int res2 = 0 ;
   27600           0 :   PyObject * obj0 = 0 ;
   27601           0 :   PyObject * obj1 = 0 ;
   27602             :   
   27603           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_utfdata_set",&obj0,&obj1)) SWIG_fail;
   27604           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27605           0 :   if (!SWIG_IsOK(res1)) {
   27606           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfdata_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27607             :   }
   27608           0 :   arg1 = (struct layerObj *)(argp1);
   27609             :   {
   27610           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_expressionObj,  0 );
   27611           0 :     if (!SWIG_IsOK(res2)) {
   27612           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_utfdata_set" "', argument " "2"" of type '" "expressionObj""'"); 
   27613             :     }  
   27614           0 :     if (!argp2) {
   27615             :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "layerObj_utfdata_set" "', argument " "2"" of type '" "expressionObj""'");
   27616             :     } else {
   27617           0 :       arg2 = *((expressionObj *)(argp2));
   27618             :     }
   27619             :   }
   27620           0 :   if (arg1) (arg1)->utfdata = arg2;
   27621             :   resultobj = SWIG_Py_Void();
   27622           0 :   return resultobj;
   27623           0 : fail:
   27624             :   return NULL;
   27625             : }
   27626             : 
   27627             : 
   27628           0 : SWIGINTERN PyObject *_wrap_layerObj_utfdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27629             :   PyObject *resultobj = 0;
   27630             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27631           0 :   void *argp1 = 0 ;
   27632             :   int res1 = 0 ;
   27633           0 :   PyObject * obj0 = 0 ;
   27634             :   expressionObj result;
   27635             :   
   27636           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_utfdata_get",&obj0)) SWIG_fail;
   27637           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27638           0 :   if (!SWIG_IsOK(res1)) {
   27639           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfdata_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27640             :   }
   27641           0 :   arg1 = (struct layerObj *)(argp1);
   27642           0 :   result =  ((arg1)->utfdata);
   27643           0 :   resultobj = SWIG_NewPointerObj((expressionObj *)memcpy((expressionObj *)calloc(1,sizeof(expressionObj)),&result,sizeof(expressionObj)), SWIGTYPE_p_expressionObj, SWIG_POINTER_OWN |  0 );
   27644           0 :   return resultobj;
   27645           0 : fail:
   27646             :   return NULL;
   27647             : }
   27648             : 
   27649             : 
   27650           0 : SWIGINTERN PyObject *_wrap_layerObj_compositer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27651             :   PyObject *resultobj = 0;
   27652             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27653             :   LayerCompositer *arg2 = (LayerCompositer *) 0 ;
   27654           0 :   void *argp1 = 0 ;
   27655             :   int res1 = 0 ;
   27656           0 :   void *argp2 = 0 ;
   27657             :   int res2 = 0 ;
   27658           0 :   PyObject * obj0 = 0 ;
   27659           0 :   PyObject * obj1 = 0 ;
   27660             :   
   27661           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_compositer_set",&obj0,&obj1)) SWIG_fail;
   27662           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27663           0 :   if (!SWIG_IsOK(res1)) {
   27664           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_compositer_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27665             :   }
   27666           0 :   arg1 = (struct layerObj *)(argp1);
   27667           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__LayerCompositer, SWIG_POINTER_DISOWN |  0 );
   27668           0 :   if (!SWIG_IsOK(res2)) {
   27669           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_compositer_set" "', argument " "2"" of type '" "LayerCompositer *""'"); 
   27670             :   }
   27671           0 :   arg2 = (LayerCompositer *)(argp2);
   27672           0 :   if (arg1) (arg1)->compositer = arg2;
   27673             :   resultobj = SWIG_Py_Void();
   27674           0 :   return resultobj;
   27675           0 : fail:
   27676             :   return NULL;
   27677             : }
   27678             : 
   27679             : 
   27680           0 : SWIGINTERN PyObject *_wrap_layerObj_compositer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27681             :   PyObject *resultobj = 0;
   27682             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27683           0 :   void *argp1 = 0 ;
   27684             :   int res1 = 0 ;
   27685           0 :   PyObject * obj0 = 0 ;
   27686             :   LayerCompositer *result = 0 ;
   27687             :   
   27688           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_compositer_get",&obj0)) SWIG_fail;
   27689           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27690           0 :   if (!SWIG_IsOK(res1)) {
   27691           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_compositer_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27692             :   }
   27693           0 :   arg1 = (struct layerObj *)(argp1);
   27694           0 :   result = (LayerCompositer *) ((arg1)->compositer);
   27695           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__LayerCompositer, 0 |  0 );
   27696           0 :   return resultobj;
   27697           0 : fail:
   27698             :   return NULL;
   27699             : }
   27700             : 
   27701             : 
   27702           0 : SWIGINTERN PyObject *_wrap_layerObj_connectionoptions_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27703             :   PyObject *resultobj = 0;
   27704             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27705             :   hashTableObj *arg2 = (hashTableObj *) 0 ;
   27706           0 :   void *argp1 = 0 ;
   27707             :   int res1 = 0 ;
   27708           0 :   void *argp2 = 0 ;
   27709             :   int res2 = 0 ;
   27710           0 :   PyObject * obj0 = 0 ;
   27711           0 :   PyObject * obj1 = 0 ;
   27712             :   
   27713           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_connectionoptions_set",&obj0,&obj1)) SWIG_fail;
   27714           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27715           0 :   if (!SWIG_IsOK(res1)) {
   27716           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectionoptions_set" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27717             :   }
   27718           0 :   arg1 = (struct layerObj *)(argp1);
   27719           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_hashTableObj, 0 |  0 );
   27720           0 :   if (!SWIG_IsOK(res2)) {
   27721           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_connectionoptions_set" "', argument " "2"" of type '" "hashTableObj *""'"); 
   27722             :   }
   27723           0 :   arg2 = (hashTableObj *)(argp2);
   27724           0 :   if (arg1) (arg1)->connectionoptions = *arg2;
   27725             :   resultobj = SWIG_Py_Void();
   27726           0 :   return resultobj;
   27727           0 : fail:
   27728             :   return NULL;
   27729             : }
   27730             : 
   27731             : 
   27732           0 : SWIGINTERN PyObject *_wrap_layerObj_connectionoptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27733             :   PyObject *resultobj = 0;
   27734             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27735           0 :   void *argp1 = 0 ;
   27736             :   int res1 = 0 ;
   27737           0 :   PyObject * obj0 = 0 ;
   27738             :   hashTableObj *result = 0 ;
   27739             :   
   27740           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_connectionoptions_get",&obj0)) SWIG_fail;
   27741           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27742           0 :   if (!SWIG_IsOK(res1)) {
   27743           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectionoptions_get" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27744             :   }
   27745           0 :   arg1 = (struct layerObj *)(argp1);
   27746           0 :   result = (hashTableObj *)& ((arg1)->connectionoptions);
   27747           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   27748           0 :   return resultobj;
   27749           0 : fail:
   27750             :   return NULL;
   27751             : }
   27752             : 
   27753             : 
   27754           1 : SWIGINTERN PyObject *_wrap_new_layerObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27755             :   PyObject *resultobj = 0;
   27756             :   mapObj *arg1 = (mapObj *) NULL ;
   27757           1 :   void *argp1 = 0 ;
   27758             :   int res1 = 0 ;
   27759           1 :   PyObject * obj0 = 0 ;
   27760             :   struct layerObj *result = 0 ;
   27761             :   
   27762           1 :   if (!PyArg_ParseTuple(args,(char *)"|O:new_layerObj",&obj0)) SWIG_fail;
   27763           1 :   if (obj0) {
   27764           1 :     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   27765           1 :     if (!SWIG_IsOK(res1)) {
   27766           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_layerObj" "', argument " "1"" of type '" "mapObj *""'"); 
   27767             :     }
   27768           1 :     arg1 = (mapObj *)(argp1);
   27769             :   }
   27770             :   {
   27771           1 :     result = (struct layerObj *)new_layerObj(arg1); {
   27772           1 :       errorObj *ms_error = msGetErrorObj();
   27773             :       
   27774           1 :       switch(ms_error->code) {
   27775             :       case MS_NOERR:
   27776             :         break;
   27777           0 :       case MS_NOTFOUND:
   27778           0 :         msResetErrorList();
   27779           0 :         break;
   27780             :       case -1:
   27781             :         break;
   27782           0 :       case MS_IOERR:
   27783           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   27784           0 :           _raise_ms_exception();
   27785           0 :           msResetErrorList();
   27786           0 :           return NULL;
   27787             :         }
   27788             :       default:
   27789           0 :         _raise_ms_exception();
   27790           0 :         msResetErrorList();
   27791           0 :         return NULL;
   27792             :       }
   27793             :       
   27794             :     }
   27795             :   }
   27796           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_NEW |  0 );
   27797           1 :   return resultobj;
   27798           0 : fail:
   27799             :   return NULL;
   27800             : }
   27801             : 
   27802             : 
   27803           0 : SWIGINTERN PyObject *_wrap_layerObj_setOpacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27804             :   PyObject *resultobj = 0;
   27805             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27806             :   int arg2 ;
   27807           0 :   void *argp1 = 0 ;
   27808             :   int res1 = 0 ;
   27809             :   int val2 ;
   27810             :   int ecode2 = 0 ;
   27811           0 :   PyObject * obj0 = 0 ;
   27812           0 :   PyObject * obj1 = 0 ;
   27813             :   
   27814           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setOpacity",&obj0,&obj1)) SWIG_fail;
   27815           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27816           0 :   if (!SWIG_IsOK(res1)) {
   27817           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setOpacity" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27818             :   }
   27819           0 :   arg1 = (struct layerObj *)(argp1);
   27820           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   27821           0 :   if (!SWIG_IsOK(ecode2)) {
   27822           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_setOpacity" "', argument " "2"" of type '" "int""'");
   27823             :   } 
   27824             :   arg2 = (int)(val2);
   27825             :   {
   27826             :     layerObj_setOpacity(arg1,arg2); {
   27827           0 :       errorObj *ms_error = msGetErrorObj();
   27828             :       
   27829           0 :       switch(ms_error->code) {
   27830             :       case MS_NOERR:
   27831             :         break;
   27832           0 :       case MS_NOTFOUND:
   27833           0 :         msResetErrorList();
   27834           0 :         break;
   27835             :       case -1:
   27836             :         break;
   27837           0 :       case MS_IOERR:
   27838           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   27839           0 :           _raise_ms_exception();
   27840           0 :           msResetErrorList();
   27841           0 :           return NULL;
   27842             :         }
   27843             :       default:
   27844           0 :         _raise_ms_exception();
   27845           0 :         msResetErrorList();
   27846           0 :         return NULL;
   27847             :       }
   27848             :       
   27849             :     }
   27850             :   }
   27851             :   resultobj = SWIG_Py_Void();
   27852           0 :   return resultobj;
   27853           0 : fail:
   27854             :   return NULL;
   27855             : }
   27856             : 
   27857             : 
   27858           0 : SWIGINTERN PyObject *_wrap_layerObj_getOpacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27859             :   PyObject *resultobj = 0;
   27860             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27861           0 :   void *argp1 = 0 ;
   27862             :   int res1 = 0 ;
   27863           0 :   PyObject * obj0 = 0 ;
   27864             :   int result;
   27865             :   
   27866           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getOpacity",&obj0)) SWIG_fail;
   27867           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27868           0 :   if (!SWIG_IsOK(res1)) {
   27869           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getOpacity" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27870             :   }
   27871           0 :   arg1 = (struct layerObj *)(argp1);
   27872             :   {
   27873           0 :     result = (int)layerObj_getOpacity(arg1); {
   27874           0 :       errorObj *ms_error = msGetErrorObj();
   27875             :       
   27876           0 :       switch(ms_error->code) {
   27877             :       case MS_NOERR:
   27878             :         break;
   27879           0 :       case MS_NOTFOUND:
   27880           0 :         msResetErrorList();
   27881           0 :         break;
   27882             :       case -1:
   27883             :         break;
   27884           0 :       case MS_IOERR:
   27885           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   27886           0 :           _raise_ms_exception();
   27887           0 :           msResetErrorList();
   27888           0 :           return NULL;
   27889             :         }
   27890             :       default:
   27891           0 :         _raise_ms_exception();
   27892           0 :         msResetErrorList();
   27893           0 :         return NULL;
   27894             :       }
   27895             :       
   27896             :     }
   27897             :   }
   27898             :   resultobj = SWIG_From_int((int)(result));
   27899           0 :   return resultobj;
   27900           0 : fail:
   27901             :   return NULL;
   27902             : }
   27903             : 
   27904             : 
   27905           1 : SWIGINTERN PyObject *_wrap_delete_layerObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27906             :   PyObject *resultobj = 0;
   27907             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27908           1 :   void *argp1 = 0 ;
   27909             :   int res1 = 0 ;
   27910           1 :   PyObject * obj0 = 0 ;
   27911             :   
   27912           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_layerObj",&obj0)) SWIG_fail;
   27913           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, SWIG_POINTER_DISOWN |  0 );
   27914           1 :   if (!SWIG_IsOK(res1)) {
   27915           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_layerObj" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27916             :   }
   27917           1 :   arg1 = (struct layerObj *)(argp1);
   27918             :   {
   27919           1 :     delete_layerObj(arg1); {
   27920           1 :       errorObj *ms_error = msGetErrorObj();
   27921             :       
   27922           1 :       switch(ms_error->code) {
   27923             :       case MS_NOERR:
   27924             :         break;
   27925           0 :       case MS_NOTFOUND:
   27926           0 :         msResetErrorList();
   27927           0 :         break;
   27928             :       case -1:
   27929             :         break;
   27930           0 :       case MS_IOERR:
   27931           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   27932           0 :           _raise_ms_exception();
   27933           0 :           msResetErrorList();
   27934           0 :           return NULL;
   27935             :         }
   27936             :       default:
   27937           0 :         _raise_ms_exception();
   27938           0 :         msResetErrorList();
   27939           0 :         return NULL;
   27940             :       }
   27941             :       
   27942             :     }
   27943             :   }
   27944             :   resultobj = SWIG_Py_Void();
   27945           1 :   return resultobj;
   27946           0 : fail:
   27947             :   return NULL;
   27948             : }
   27949             : 
   27950             : 
   27951           1 : SWIGINTERN PyObject *_wrap_layerObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27952             :   PyObject *resultobj = 0;
   27953             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   27954           1 :   void *argp1 = 0 ;
   27955             :   int res1 = 0 ;
   27956           1 :   PyObject * obj0 = 0 ;
   27957             :   layerObj *result = 0 ;
   27958             :   
   27959           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_clone",&obj0)) SWIG_fail;
   27960           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   27961           1 :   if (!SWIG_IsOK(res1)) {
   27962           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_clone" "', argument " "1"" of type '" "struct layerObj *""'"); 
   27963             :   }
   27964           1 :   arg1 = (struct layerObj *)(argp1);
   27965             :   {
   27966           1 :     result = (layerObj *)layerObj_clone(arg1); {
   27967           1 :       errorObj *ms_error = msGetErrorObj();
   27968             :       
   27969           1 :       switch(ms_error->code) {
   27970             :       case MS_NOERR:
   27971             :         break;
   27972           0 :       case MS_NOTFOUND:
   27973           0 :         msResetErrorList();
   27974           0 :         break;
   27975             :       case -1:
   27976             :         break;
   27977           0 :       case MS_IOERR:
   27978           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   27979           0 :           _raise_ms_exception();
   27980           0 :           msResetErrorList();
   27981           0 :           return NULL;
   27982             :         }
   27983             :       default:
   27984           0 :         _raise_ms_exception();
   27985           0 :         msResetErrorList();
   27986           0 :         return NULL;
   27987             :       }
   27988             :       
   27989             :     }
   27990             :   }
   27991           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN |  0 );
   27992           1 :   return resultobj;
   27993           0 : fail:
   27994             :   return NULL;
   27995             : }
   27996             : 
   27997             : 
   27998           1 : SWIGINTERN PyObject *_wrap_layerObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   27999             :   PyObject *resultobj = 0;
   28000             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28001             :   char *arg2 = (char *) 0 ;
   28002           1 :   void *argp1 = 0 ;
   28003             :   int res1 = 0 ;
   28004             :   int res2 ;
   28005           1 :   char *buf2 = 0 ;
   28006           1 :   int alloc2 = 0 ;
   28007           1 :   PyObject * obj0 = 0 ;
   28008           1 :   PyObject * obj1 = 0 ;
   28009             :   int result;
   28010             :   
   28011           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_updateFromString",&obj0,&obj1)) SWIG_fail;
   28012           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28013           1 :   if (!SWIG_IsOK(res1)) {
   28014           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_updateFromString" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28015             :   }
   28016           1 :   arg1 = (struct layerObj *)(argp1);
   28017           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   28018           1 :   if (!SWIG_IsOK(res2)) {
   28019           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_updateFromString" "', argument " "2"" of type '" "char *""'");
   28020             :   }
   28021           1 :   arg2 = (char *)(buf2);
   28022             :   {
   28023             :     result = (int)layerObj_updateFromString(arg1,arg2); {
   28024           1 :       errorObj *ms_error = msGetErrorObj();
   28025             :       
   28026           1 :       switch(ms_error->code) {
   28027             :       case MS_NOERR:
   28028             :         break;
   28029           0 :       case MS_NOTFOUND:
   28030           0 :         msResetErrorList();
   28031           0 :         break;
   28032             :       case -1:
   28033             :         break;
   28034           0 :       case MS_IOERR:
   28035           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28036           0 :           _raise_ms_exception();
   28037           0 :           msResetErrorList();
   28038           0 :           return NULL;
   28039             :         }
   28040             :       default:
   28041           0 :         _raise_ms_exception();
   28042           0 :         msResetErrorList();
   28043           0 :         return NULL;
   28044             :       }
   28045             :       
   28046             :     }
   28047             :   }
   28048             :   resultobj = SWIG_From_int((int)(result));
   28049           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   28050             :   return resultobj;
   28051           0 : fail:
   28052           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   28053             :   return NULL;
   28054             : }
   28055             : 
   28056             : 
   28057           0 : SWIGINTERN PyObject *_wrap_layerObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28058             :   PyObject *resultobj = 0;
   28059             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28060           0 :   void *argp1 = 0 ;
   28061             :   int res1 = 0 ;
   28062           0 :   PyObject * obj0 = 0 ;
   28063             :   char *result = 0 ;
   28064             :   
   28065           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_convertToString",&obj0)) SWIG_fail;
   28066           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28067           0 :   if (!SWIG_IsOK(res1)) {
   28068           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_convertToString" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28069             :   }
   28070           0 :   arg1 = (struct layerObj *)(argp1);
   28071             :   {
   28072             :     result = (char *)layerObj_convertToString(arg1); {
   28073           0 :       errorObj *ms_error = msGetErrorObj();
   28074             :       
   28075           0 :       switch(ms_error->code) {
   28076             :       case MS_NOERR:
   28077             :         break;
   28078           0 :       case MS_NOTFOUND:
   28079           0 :         msResetErrorList();
   28080           0 :         break;
   28081             :       case -1:
   28082             :         break;
   28083           0 :       case MS_IOERR:
   28084           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28085           0 :           _raise_ms_exception();
   28086           0 :           msResetErrorList();
   28087           0 :           return NULL;
   28088             :         }
   28089             :       default:
   28090           0 :         _raise_ms_exception();
   28091           0 :         msResetErrorList();
   28092           0 :         return NULL;
   28093             :       }
   28094             :       
   28095             :     }
   28096             :   }
   28097           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   28098           0 :   free((char*)result);
   28099           0 :   return resultobj;
   28100           0 : fail:
   28101             :   return NULL;
   28102             : }
   28103             : 
   28104             : 
   28105           1 : SWIGINTERN PyObject *_wrap_layerObj_insertClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28106             :   PyObject *resultobj = 0;
   28107             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28108             :   classObj *arg2 = (classObj *) 0 ;
   28109             :   int arg3 = (int) -1 ;
   28110           1 :   void *argp1 = 0 ;
   28111             :   int res1 = 0 ;
   28112           1 :   void *argp2 = 0 ;
   28113             :   int res2 = 0 ;
   28114             :   int val3 ;
   28115             :   int ecode3 = 0 ;
   28116           1 :   PyObject * obj0 = 0 ;
   28117           1 :   PyObject * obj1 = 0 ;
   28118           1 :   PyObject * obj2 = 0 ;
   28119             :   int result;
   28120             :   
   28121           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:layerObj_insertClass",&obj0,&obj1,&obj2)) SWIG_fail;
   28122           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28123           1 :   if (!SWIG_IsOK(res1)) {
   28124           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_insertClass" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28125             :   }
   28126           1 :   arg1 = (struct layerObj *)(argp1);
   28127           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_classObj, 0 |  0 );
   28128           1 :   if (!SWIG_IsOK(res2)) {
   28129           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_insertClass" "', argument " "2"" of type '" "classObj *""'"); 
   28130             :   }
   28131           1 :   arg2 = (classObj *)(argp2);
   28132           1 :   if (obj2) {
   28133             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   28134           1 :     if (!SWIG_IsOK(ecode3)) {
   28135           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_insertClass" "', argument " "3"" of type '" "int""'");
   28136             :     } 
   28137             :     arg3 = (int)(val3);
   28138             :   }
   28139             :   {
   28140             :     result = (int)layerObj_insertClass(arg1,arg2,arg3); {
   28141           1 :       errorObj *ms_error = msGetErrorObj();
   28142             :       
   28143           1 :       switch(ms_error->code) {
   28144             :       case MS_NOERR:
   28145             :         break;
   28146           0 :       case MS_NOTFOUND:
   28147           0 :         msResetErrorList();
   28148           0 :         break;
   28149             :       case -1:
   28150             :         break;
   28151           0 :       case MS_IOERR:
   28152           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28153           0 :           _raise_ms_exception();
   28154           0 :           msResetErrorList();
   28155           0 :           return NULL;
   28156             :         }
   28157             :       default:
   28158           1 :         _raise_ms_exception();
   28159           1 :         msResetErrorList();
   28160           1 :         return NULL;
   28161             :       }
   28162             :       
   28163             :     }
   28164             :   }
   28165             :   resultobj = SWIG_From_int((int)(result));
   28166           1 :   return resultobj;
   28167           0 : fail:
   28168             :   return NULL;
   28169             : }
   28170             : 
   28171             : 
   28172           1 : SWIGINTERN PyObject *_wrap_layerObj_removeClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28173             :   PyObject *resultobj = 0;
   28174             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28175             :   int arg2 ;
   28176           1 :   void *argp1 = 0 ;
   28177             :   int res1 = 0 ;
   28178             :   int val2 ;
   28179             :   int ecode2 = 0 ;
   28180           1 :   PyObject * obj0 = 0 ;
   28181           1 :   PyObject * obj1 = 0 ;
   28182             :   classObj *result = 0 ;
   28183             :   
   28184           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_removeClass",&obj0,&obj1)) SWIG_fail;
   28185           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28186           1 :   if (!SWIG_IsOK(res1)) {
   28187           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_removeClass" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28188             :   }
   28189           1 :   arg1 = (struct layerObj *)(argp1);
   28190           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   28191           1 :   if (!SWIG_IsOK(ecode2)) {
   28192           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_removeClass" "', argument " "2"" of type '" "int""'");
   28193             :   } 
   28194             :   arg2 = (int)(val2);
   28195             :   {
   28196           1 :     result = (classObj *)layerObj_removeClass(arg1,arg2); {
   28197           1 :       errorObj *ms_error = msGetErrorObj();
   28198             :       
   28199           1 :       switch(ms_error->code) {
   28200             :       case MS_NOERR:
   28201             :         break;
   28202           0 :       case MS_NOTFOUND:
   28203           0 :         msResetErrorList();
   28204           0 :         break;
   28205             :       case -1:
   28206             :         break;
   28207           0 :       case MS_IOERR:
   28208           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28209           0 :           _raise_ms_exception();
   28210           0 :           msResetErrorList();
   28211           0 :           return NULL;
   28212             :         }
   28213             :       default:
   28214           0 :         _raise_ms_exception();
   28215           0 :         msResetErrorList();
   28216           0 :         return NULL;
   28217             :       }
   28218             :       
   28219             :     }
   28220             :   }
   28221           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_OWN |  0 );
   28222           1 :   return resultobj;
   28223           0 : fail:
   28224             :   return NULL;
   28225             : }
   28226             : 
   28227             : 
   28228           1 : SWIGINTERN PyObject *_wrap_layerObj_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28229             :   PyObject *resultobj = 0;
   28230             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28231           1 :   void *argp1 = 0 ;
   28232             :   int res1 = 0 ;
   28233           1 :   PyObject * obj0 = 0 ;
   28234             :   int result;
   28235             :   
   28236           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_open",&obj0)) SWIG_fail;
   28237           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28238           1 :   if (!SWIG_IsOK(res1)) {
   28239           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_open" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28240             :   }
   28241           1 :   arg1 = (struct layerObj *)(argp1);
   28242             :   {
   28243           1 :     result = (int)layerObj_open(arg1); {
   28244           1 :       errorObj *ms_error = msGetErrorObj();
   28245             :       
   28246           1 :       switch(ms_error->code) {
   28247             :       case MS_NOERR:
   28248             :         break;
   28249           0 :       case MS_NOTFOUND:
   28250           0 :         msResetErrorList();
   28251           0 :         break;
   28252             :       case -1:
   28253             :         break;
   28254           1 :       case MS_IOERR:
   28255           1 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28256           1 :           _raise_ms_exception();
   28257           1 :           msResetErrorList();
   28258           1 :           return NULL;
   28259             :         }
   28260             :       default:
   28261           0 :         _raise_ms_exception();
   28262           0 :         msResetErrorList();
   28263           0 :         return NULL;
   28264             :       }
   28265             :       
   28266             :     }
   28267             :   }
   28268             :   resultobj = SWIG_From_int((int)(result));
   28269           1 :   return resultobj;
   28270           0 : fail:
   28271             :   return NULL;
   28272             : }
   28273             : 
   28274             : 
   28275           0 : SWIGINTERN PyObject *_wrap_layerObj_whichShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28276             :   PyObject *resultobj = 0;
   28277             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28278             :   rectObj arg2 ;
   28279           0 :   void *argp1 = 0 ;
   28280             :   int res1 = 0 ;
   28281             :   void *argp2 ;
   28282             :   int res2 = 0 ;
   28283           0 :   PyObject * obj0 = 0 ;
   28284           0 :   PyObject * obj1 = 0 ;
   28285             :   int result;
   28286             :   
   28287           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_whichShapes",&obj0,&obj1)) SWIG_fail;
   28288           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28289           0 :   if (!SWIG_IsOK(res1)) {
   28290           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_whichShapes" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28291             :   }
   28292           0 :   arg1 = (struct layerObj *)(argp1);
   28293             :   {
   28294           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_rectObj,  0 );
   28295           0 :     if (!SWIG_IsOK(res2)) {
   28296           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_whichShapes" "', argument " "2"" of type '" "rectObj""'"); 
   28297             :     }  
   28298           0 :     if (!argp2) {
   28299             :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "layerObj_whichShapes" "', argument " "2"" of type '" "rectObj""'");
   28300             :     } else {
   28301           0 :       arg2 = *((rectObj *)(argp2));
   28302             :     }
   28303             :   }
   28304             :   {
   28305           0 :     result = (int)layerObj_whichShapes(arg1,arg2); {
   28306           0 :       errorObj *ms_error = msGetErrorObj();
   28307             :       
   28308           0 :       switch(ms_error->code) {
   28309             :       case MS_NOERR:
   28310             :         break;
   28311           0 :       case MS_NOTFOUND:
   28312           0 :         msResetErrorList();
   28313           0 :         break;
   28314             :       case -1:
   28315             :         break;
   28316           0 :       case MS_IOERR:
   28317           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28318           0 :           _raise_ms_exception();
   28319           0 :           msResetErrorList();
   28320           0 :           return NULL;
   28321             :         }
   28322             :       default:
   28323           0 :         _raise_ms_exception();
   28324           0 :         msResetErrorList();
   28325           0 :         return NULL;
   28326             :       }
   28327             :       
   28328             :     }
   28329             :   }
   28330             :   resultobj = SWIG_From_int((int)(result));
   28331           0 :   return resultobj;
   28332           0 : fail:
   28333             :   return NULL;
   28334             : }
   28335             : 
   28336             : 
   28337           0 : SWIGINTERN PyObject *_wrap_layerObj_nextShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28338             :   PyObject *resultobj = 0;
   28339             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28340           0 :   void *argp1 = 0 ;
   28341             :   int res1 = 0 ;
   28342           0 :   PyObject * obj0 = 0 ;
   28343             :   shapeObj *result = 0 ;
   28344             :   
   28345           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_nextShape",&obj0)) SWIG_fail;
   28346           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28347           0 :   if (!SWIG_IsOK(res1)) {
   28348           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_nextShape" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28349             :   }
   28350           0 :   arg1 = (struct layerObj *)(argp1);
   28351             :   {
   28352           0 :     result = (shapeObj *)layerObj_nextShape(arg1); {
   28353           0 :       errorObj *ms_error = msGetErrorObj();
   28354             :       
   28355           0 :       switch(ms_error->code) {
   28356             :       case MS_NOERR:
   28357             :         break;
   28358           0 :       case MS_NOTFOUND:
   28359           0 :         msResetErrorList();
   28360           0 :         break;
   28361             :       case -1:
   28362             :         break;
   28363           0 :       case MS_IOERR:
   28364           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28365           0 :           _raise_ms_exception();
   28366           0 :           msResetErrorList();
   28367           0 :           return NULL;
   28368             :         }
   28369             :       default:
   28370           0 :         _raise_ms_exception();
   28371           0 :         msResetErrorList();
   28372           0 :         return NULL;
   28373             :       }
   28374             :       
   28375             :     }
   28376             :   }
   28377           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   28378           0 :   return resultobj;
   28379           0 : fail:
   28380             :   return NULL;
   28381             : }
   28382             : 
   28383             : 
   28384           1 : SWIGINTERN PyObject *_wrap_layerObj_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28385             :   PyObject *resultobj = 0;
   28386             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28387           1 :   void *argp1 = 0 ;
   28388             :   int res1 = 0 ;
   28389           1 :   PyObject * obj0 = 0 ;
   28390             :   
   28391           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_close",&obj0)) SWIG_fail;
   28392           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28393           1 :   if (!SWIG_IsOK(res1)) {
   28394           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_close" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28395             :   }
   28396           1 :   arg1 = (struct layerObj *)(argp1);
   28397             :   {
   28398             :     layerObj_close(arg1); {
   28399           1 :       errorObj *ms_error = msGetErrorObj();
   28400             :       
   28401           1 :       switch(ms_error->code) {
   28402             :       case MS_NOERR:
   28403             :         break;
   28404           0 :       case MS_NOTFOUND:
   28405           0 :         msResetErrorList();
   28406           0 :         break;
   28407             :       case -1:
   28408             :         break;
   28409           0 :       case MS_IOERR:
   28410           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28411           0 :           _raise_ms_exception();
   28412           0 :           msResetErrorList();
   28413           0 :           return NULL;
   28414             :         }
   28415             :       default:
   28416           0 :         _raise_ms_exception();
   28417           0 :         msResetErrorList();
   28418           0 :         return NULL;
   28419             :       }
   28420             :       
   28421             :     }
   28422             :   }
   28423             :   resultobj = SWIG_Py_Void();
   28424           1 :   return resultobj;
   28425           0 : fail:
   28426             :   return NULL;
   28427             : }
   28428             : 
   28429             : 
   28430           1 : SWIGINTERN PyObject *_wrap_layerObj_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28431             :   PyObject *resultobj = 0;
   28432             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28433             :   resultObj *arg2 = (resultObj *) 0 ;
   28434           1 :   void *argp1 = 0 ;
   28435             :   int res1 = 0 ;
   28436           1 :   void *argp2 = 0 ;
   28437             :   int res2 = 0 ;
   28438           1 :   PyObject * obj0 = 0 ;
   28439           1 :   PyObject * obj1 = 0 ;
   28440             :   shapeObj *result = 0 ;
   28441             :   
   28442           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getShape",&obj0,&obj1)) SWIG_fail;
   28443           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28444           1 :   if (!SWIG_IsOK(res1)) {
   28445           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getShape" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28446             :   }
   28447           1 :   arg1 = (struct layerObj *)(argp1);
   28448           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_resultObj, 0 |  0 );
   28449           1 :   if (!SWIG_IsOK(res2)) {
   28450           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getShape" "', argument " "2"" of type '" "resultObj *""'"); 
   28451             :   }
   28452           1 :   arg2 = (resultObj *)(argp2);
   28453             :   {
   28454           1 :     result = (shapeObj *)layerObj_getShape(arg1,arg2); {
   28455           1 :       errorObj *ms_error = msGetErrorObj();
   28456             :       
   28457           1 :       switch(ms_error->code) {
   28458             :       case MS_NOERR:
   28459             :         break;
   28460           0 :       case MS_NOTFOUND:
   28461           0 :         msResetErrorList();
   28462           0 :         break;
   28463             :       case -1:
   28464             :         break;
   28465           0 :       case MS_IOERR:
   28466           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28467           0 :           _raise_ms_exception();
   28468           0 :           msResetErrorList();
   28469           0 :           return NULL;
   28470             :         }
   28471             :       default:
   28472           0 :         _raise_ms_exception();
   28473           0 :         msResetErrorList();
   28474           0 :         return NULL;
   28475             :       }
   28476             :       
   28477             :     }
   28478             :   }
   28479           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   28480           1 :   return resultobj;
   28481           0 : fail:
   28482             :   return NULL;
   28483             : }
   28484             : 
   28485             : 
   28486           1 : SWIGINTERN PyObject *_wrap_layerObj_getNumResults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28487             :   PyObject *resultobj = 0;
   28488             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28489           1 :   void *argp1 = 0 ;
   28490             :   int res1 = 0 ;
   28491           1 :   PyObject * obj0 = 0 ;
   28492             :   int result;
   28493             :   
   28494           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getNumResults",&obj0)) SWIG_fail;
   28495           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28496           1 :   if (!SWIG_IsOK(res1)) {
   28497           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getNumResults" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28498             :   }
   28499           1 :   arg1 = (struct layerObj *)(argp1);
   28500             :   {
   28501           1 :     result = (int)layerObj_getNumResults(arg1); {
   28502           1 :       errorObj *ms_error = msGetErrorObj();
   28503             :       
   28504           1 :       switch(ms_error->code) {
   28505             :       case MS_NOERR:
   28506             :         break;
   28507           0 :       case MS_NOTFOUND:
   28508           0 :         msResetErrorList();
   28509           0 :         break;
   28510             :       case -1:
   28511             :         break;
   28512           0 :       case MS_IOERR:
   28513           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28514           0 :           _raise_ms_exception();
   28515           0 :           msResetErrorList();
   28516           0 :           return NULL;
   28517             :         }
   28518             :       default:
   28519           0 :         _raise_ms_exception();
   28520           0 :         msResetErrorList();
   28521           0 :         return NULL;
   28522             :       }
   28523             :       
   28524             :     }
   28525             :   }
   28526             :   resultobj = SWIG_From_int((int)(result));
   28527           1 :   return resultobj;
   28528           0 : fail:
   28529             :   return NULL;
   28530             : }
   28531             : 
   28532             : 
   28533           0 : SWIGINTERN PyObject *_wrap_layerObj_getResultsBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28534             :   PyObject *resultobj = 0;
   28535             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28536           0 :   void *argp1 = 0 ;
   28537             :   int res1 = 0 ;
   28538           0 :   PyObject * obj0 = 0 ;
   28539             :   rectObj *result = 0 ;
   28540             :   
   28541           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getResultsBounds",&obj0)) SWIG_fail;
   28542           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28543           0 :   if (!SWIG_IsOK(res1)) {
   28544           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getResultsBounds" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28545             :   }
   28546           0 :   arg1 = (struct layerObj *)(argp1);
   28547             :   {
   28548           0 :     result = (rectObj *)layerObj_getResultsBounds(arg1); {
   28549           0 :       errorObj *ms_error = msGetErrorObj();
   28550             :       
   28551           0 :       switch(ms_error->code) {
   28552             :       case MS_NOERR:
   28553             :         break;
   28554           0 :       case MS_NOTFOUND:
   28555           0 :         msResetErrorList();
   28556           0 :         break;
   28557             :       case -1:
   28558             :         break;
   28559           0 :       case MS_IOERR:
   28560           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28561           0 :           _raise_ms_exception();
   28562           0 :           msResetErrorList();
   28563           0 :           return NULL;
   28564             :         }
   28565             :       default:
   28566           0 :         _raise_ms_exception();
   28567           0 :         msResetErrorList();
   28568           0 :         return NULL;
   28569             :       }
   28570             :       
   28571             :     }
   28572             :   }
   28573           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, SWIG_POINTER_OWN |  0 );
   28574           0 :   return resultobj;
   28575           0 : fail:
   28576             :   return NULL;
   28577             : }
   28578             : 
   28579             : 
   28580           1 : SWIGINTERN PyObject *_wrap_layerObj_getResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28581             :   PyObject *resultobj = 0;
   28582             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28583             :   int arg2 ;
   28584           1 :   void *argp1 = 0 ;
   28585             :   int res1 = 0 ;
   28586             :   int val2 ;
   28587             :   int ecode2 = 0 ;
   28588           1 :   PyObject * obj0 = 0 ;
   28589           1 :   PyObject * obj1 = 0 ;
   28590             :   resultObj *result = 0 ;
   28591             :   
   28592           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getResult",&obj0,&obj1)) SWIG_fail;
   28593           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28594           1 :   if (!SWIG_IsOK(res1)) {
   28595           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getResult" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28596             :   }
   28597           1 :   arg1 = (struct layerObj *)(argp1);
   28598           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   28599           1 :   if (!SWIG_IsOK(ecode2)) {
   28600           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getResult" "', argument " "2"" of type '" "int""'");
   28601             :   } 
   28602             :   arg2 = (int)(val2);
   28603             :   {
   28604           1 :     result = (resultObj *)layerObj_getResult(arg1,arg2); {
   28605           1 :       errorObj *ms_error = msGetErrorObj();
   28606             :       
   28607           1 :       switch(ms_error->code) {
   28608             :       case MS_NOERR:
   28609             :         break;
   28610           0 :       case MS_NOTFOUND:
   28611           0 :         msResetErrorList();
   28612           0 :         break;
   28613             :       case -1:
   28614             :         break;
   28615           0 :       case MS_IOERR:
   28616           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28617           0 :           _raise_ms_exception();
   28618           0 :           msResetErrorList();
   28619           0 :           return NULL;
   28620             :         }
   28621             :       default:
   28622           0 :         _raise_ms_exception();
   28623           0 :         msResetErrorList();
   28624           0 :         return NULL;
   28625             :       }
   28626             :       
   28627             :     }
   28628             :   }
   28629           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultObj, 0 |  0 );
   28630           1 :   return resultobj;
   28631           0 : fail:
   28632             :   return NULL;
   28633             : }
   28634             : 
   28635             : 
   28636           1 : SWIGINTERN PyObject *_wrap_layerObj_getClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28637             :   PyObject *resultobj = 0;
   28638             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28639             :   int arg2 ;
   28640           1 :   void *argp1 = 0 ;
   28641             :   int res1 = 0 ;
   28642             :   int val2 ;
   28643             :   int ecode2 = 0 ;
   28644           1 :   PyObject * obj0 = 0 ;
   28645           1 :   PyObject * obj1 = 0 ;
   28646             :   classObj *result = 0 ;
   28647             :   
   28648           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getClass",&obj0,&obj1)) SWIG_fail;
   28649           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28650           1 :   if (!SWIG_IsOK(res1)) {
   28651           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getClass" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28652             :   }
   28653           1 :   arg1 = (struct layerObj *)(argp1);
   28654           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   28655           1 :   if (!SWIG_IsOK(ecode2)) {
   28656           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getClass" "', argument " "2"" of type '" "int""'");
   28657             :   } 
   28658             :   arg2 = (int)(val2);
   28659             :   {
   28660             :     result = (classObj *)layerObj_getClass(arg1,arg2); {
   28661           1 :       errorObj *ms_error = msGetErrorObj();
   28662             :       
   28663           1 :       switch(ms_error->code) {
   28664             :       case MS_NOERR:
   28665             :         break;
   28666           0 :       case MS_NOTFOUND:
   28667           0 :         msResetErrorList();
   28668           0 :         break;
   28669             :       case -1:
   28670             :         break;
   28671           0 :       case MS_IOERR:
   28672           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28673           0 :           _raise_ms_exception();
   28674           0 :           msResetErrorList();
   28675           0 :           return NULL;
   28676             :         }
   28677             :       default:
   28678           0 :         _raise_ms_exception();
   28679           0 :         msResetErrorList();
   28680           0 :         return NULL;
   28681             :       }
   28682             :       
   28683             :     }
   28684             :   }
   28685           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_OWN |  0 );
   28686           1 :   return resultobj;
   28687           0 : fail:
   28688             :   return NULL;
   28689             : }
   28690             : 
   28691             : 
   28692           1 : SWIGINTERN PyObject *_wrap_layerObj_getItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28693             :   PyObject *resultobj = 0;
   28694             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28695             :   int arg2 ;
   28696           1 :   void *argp1 = 0 ;
   28697             :   int res1 = 0 ;
   28698             :   int val2 ;
   28699             :   int ecode2 = 0 ;
   28700           1 :   PyObject * obj0 = 0 ;
   28701           1 :   PyObject * obj1 = 0 ;
   28702             :   char *result = 0 ;
   28703             :   
   28704           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getItem",&obj0,&obj1)) SWIG_fail;
   28705           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28706           1 :   if (!SWIG_IsOK(res1)) {
   28707           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getItem" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28708             :   }
   28709           1 :   arg1 = (struct layerObj *)(argp1);
   28710           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   28711           1 :   if (!SWIG_IsOK(ecode2)) {
   28712           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getItem" "', argument " "2"" of type '" "int""'");
   28713             :   } 
   28714             :   arg2 = (int)(val2);
   28715             :   {
   28716             :     result = (char *)layerObj_getItem(arg1,arg2); {
   28717           1 :       errorObj *ms_error = msGetErrorObj();
   28718             :       
   28719           1 :       switch(ms_error->code) {
   28720             :       case MS_NOERR:
   28721             :         break;
   28722           0 :       case MS_NOTFOUND:
   28723           0 :         msResetErrorList();
   28724           0 :         break;
   28725             :       case -1:
   28726             :         break;
   28727           0 :       case MS_IOERR:
   28728           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28729           0 :           _raise_ms_exception();
   28730           0 :           msResetErrorList();
   28731           0 :           return NULL;
   28732             :         }
   28733             :       default:
   28734           0 :         _raise_ms_exception();
   28735           0 :         msResetErrorList();
   28736           0 :         return NULL;
   28737             :       }
   28738             :       
   28739             :     }
   28740             :   }
   28741           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   28742           1 :   return resultobj;
   28743           0 : fail:
   28744             :   return NULL;
   28745             : }
   28746             : 
   28747             : 
   28748           0 : SWIGINTERN PyObject *_wrap_layerObj_setItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28749             :   PyObject *resultobj = 0;
   28750             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28751             :   char **arg2 = (char **) 0 ;
   28752             :   int arg3 ;
   28753           0 :   void *argp1 = 0 ;
   28754             :   int res1 = 0 ;
   28755           0 :   void *argp2 = 0 ;
   28756             :   int res2 = 0 ;
   28757             :   int val3 ;
   28758             :   int ecode3 = 0 ;
   28759           0 :   PyObject * obj0 = 0 ;
   28760           0 :   PyObject * obj1 = 0 ;
   28761           0 :   PyObject * obj2 = 0 ;
   28762             :   int result;
   28763             :   
   28764           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setItems",&obj0,&obj1,&obj2)) SWIG_fail;
   28765           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28766           0 :   if (!SWIG_IsOK(res1)) {
   28767           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setItems" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28768             :   }
   28769           0 :   arg1 = (struct layerObj *)(argp1);
   28770           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
   28771           0 :   if (!SWIG_IsOK(res2)) {
   28772           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setItems" "', argument " "2"" of type '" "char **""'"); 
   28773             :   }
   28774           0 :   arg2 = (char **)(argp2);
   28775           0 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   28776           0 :   if (!SWIG_IsOK(ecode3)) {
   28777           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_setItems" "', argument " "3"" of type '" "int""'");
   28778             :   } 
   28779             :   arg3 = (int)(val3);
   28780             :   {
   28781             :     result = (int)layerObj_setItems(arg1,arg2,arg3); {
   28782           0 :       errorObj *ms_error = msGetErrorObj();
   28783             :       
   28784           0 :       switch(ms_error->code) {
   28785             :       case MS_NOERR:
   28786             :         break;
   28787           0 :       case MS_NOTFOUND:
   28788           0 :         msResetErrorList();
   28789           0 :         break;
   28790             :       case -1:
   28791             :         break;
   28792           0 :       case MS_IOERR:
   28793           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28794           0 :           _raise_ms_exception();
   28795           0 :           msResetErrorList();
   28796           0 :           return NULL;
   28797             :         }
   28798             :       default:
   28799           0 :         _raise_ms_exception();
   28800           0 :         msResetErrorList();
   28801           0 :         return NULL;
   28802             :       }
   28803             :       
   28804             :     }
   28805             :   }
   28806             :   resultobj = SWIG_From_int((int)(result));
   28807           0 :   return resultobj;
   28808           0 : fail:
   28809             :   return NULL;
   28810             : }
   28811             : 
   28812             : 
   28813           0 : SWIGINTERN PyObject *_wrap_layerObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28814             :   PyObject *resultobj = 0;
   28815             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28816             :   mapObj *arg2 = (mapObj *) 0 ;
   28817             :   imageObj *arg3 = (imageObj *) 0 ;
   28818           0 :   void *argp1 = 0 ;
   28819             :   int res1 = 0 ;
   28820           0 :   void *argp2 = 0 ;
   28821             :   int res2 = 0 ;
   28822           0 :   void *argp3 = 0 ;
   28823             :   int res3 = 0 ;
   28824           0 :   PyObject * obj0 = 0 ;
   28825           0 :   PyObject * obj1 = 0 ;
   28826           0 :   PyObject * obj2 = 0 ;
   28827             :   int result;
   28828             :   
   28829           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_draw",&obj0,&obj1,&obj2)) SWIG_fail;
   28830           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28831           0 :   if (!SWIG_IsOK(res1)) {
   28832           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_draw" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28833             :   }
   28834           0 :   arg1 = (struct layerObj *)(argp1);
   28835           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   28836           0 :   if (!SWIG_IsOK(res2)) {
   28837           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_draw" "', argument " "2"" of type '" "mapObj *""'"); 
   28838             :   }
   28839           0 :   arg2 = (mapObj *)(argp2);
   28840           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_imageObj, 0 |  0 );
   28841           0 :   if (!SWIG_IsOK(res3)) {
   28842           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_draw" "', argument " "3"" of type '" "imageObj *""'"); 
   28843             :   }
   28844           0 :   arg3 = (imageObj *)(argp3);
   28845             :   {
   28846             :     result = (int)layerObj_draw(arg1,arg2,arg3); {
   28847           0 :       errorObj *ms_error = msGetErrorObj();
   28848             :       
   28849           0 :       switch(ms_error->code) {
   28850             :       case MS_NOERR:
   28851             :         break;
   28852           0 :       case MS_NOTFOUND:
   28853           0 :         msResetErrorList();
   28854           0 :         break;
   28855             :       case -1:
   28856             :         break;
   28857           0 :       case MS_IOERR:
   28858           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28859           0 :           _raise_ms_exception();
   28860           0 :           msResetErrorList();
   28861           0 :           return NULL;
   28862             :         }
   28863             :       default:
   28864           0 :         _raise_ms_exception();
   28865           0 :         msResetErrorList();
   28866           0 :         return NULL;
   28867             :       }
   28868             :       
   28869             :     }
   28870             :   }
   28871             :   resultobj = SWIG_From_int((int)(result));
   28872           0 :   return resultobj;
   28873           0 : fail:
   28874             :   return NULL;
   28875             : }
   28876             : 
   28877             : 
   28878           0 : SWIGINTERN PyObject *_wrap_layerObj_drawQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28879             :   PyObject *resultobj = 0;
   28880             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28881             :   mapObj *arg2 = (mapObj *) 0 ;
   28882             :   imageObj *arg3 = (imageObj *) 0 ;
   28883           0 :   void *argp1 = 0 ;
   28884             :   int res1 = 0 ;
   28885           0 :   void *argp2 = 0 ;
   28886             :   int res2 = 0 ;
   28887           0 :   void *argp3 = 0 ;
   28888             :   int res3 = 0 ;
   28889           0 :   PyObject * obj0 = 0 ;
   28890           0 :   PyObject * obj1 = 0 ;
   28891           0 :   PyObject * obj2 = 0 ;
   28892             :   int result;
   28893             :   
   28894           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_drawQuery",&obj0,&obj1,&obj2)) SWIG_fail;
   28895           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28896           0 :   if (!SWIG_IsOK(res1)) {
   28897           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_drawQuery" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28898             :   }
   28899           0 :   arg1 = (struct layerObj *)(argp1);
   28900           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   28901           0 :   if (!SWIG_IsOK(res2)) {
   28902           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_drawQuery" "', argument " "2"" of type '" "mapObj *""'"); 
   28903             :   }
   28904           0 :   arg2 = (mapObj *)(argp2);
   28905           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_imageObj, 0 |  0 );
   28906           0 :   if (!SWIG_IsOK(res3)) {
   28907           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_drawQuery" "', argument " "3"" of type '" "imageObj *""'"); 
   28908             :   }
   28909           0 :   arg3 = (imageObj *)(argp3);
   28910             :   {
   28911             :     result = (int)layerObj_drawQuery(arg1,arg2,arg3); {
   28912           0 :       errorObj *ms_error = msGetErrorObj();
   28913             :       
   28914           0 :       switch(ms_error->code) {
   28915             :       case MS_NOERR:
   28916             :         break;
   28917           0 :       case MS_NOTFOUND:
   28918           0 :         msResetErrorList();
   28919           0 :         break;
   28920             :       case -1:
   28921             :         break;
   28922           0 :       case MS_IOERR:
   28923           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28924           0 :           _raise_ms_exception();
   28925           0 :           msResetErrorList();
   28926           0 :           return NULL;
   28927             :         }
   28928             :       default:
   28929           0 :         _raise_ms_exception();
   28930           0 :         msResetErrorList();
   28931           0 :         return NULL;
   28932             :       }
   28933             :       
   28934             :     }
   28935             :   }
   28936             :   resultobj = SWIG_From_int((int)(result));
   28937           0 :   return resultobj;
   28938           0 : fail:
   28939             :   return NULL;
   28940             : }
   28941             : 
   28942             : 
   28943           0 : SWIGINTERN PyObject *_wrap_layerObj_queryByFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   28944             :   PyObject *resultobj = 0;
   28945             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   28946             :   mapObj *arg2 = (mapObj *) 0 ;
   28947             :   char *arg3 = (char *) 0 ;
   28948           0 :   void *argp1 = 0 ;
   28949             :   int res1 = 0 ;
   28950           0 :   void *argp2 = 0 ;
   28951             :   int res2 = 0 ;
   28952             :   int res3 ;
   28953           0 :   char *buf3 = 0 ;
   28954           0 :   int alloc3 = 0 ;
   28955           0 :   PyObject * obj0 = 0 ;
   28956           0 :   PyObject * obj1 = 0 ;
   28957           0 :   PyObject * obj2 = 0 ;
   28958             :   int result;
   28959             :   
   28960           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByFilter",&obj0,&obj1,&obj2)) SWIG_fail;
   28961           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   28962           0 :   if (!SWIG_IsOK(res1)) {
   28963           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByFilter" "', argument " "1"" of type '" "struct layerObj *""'"); 
   28964             :   }
   28965           0 :   arg1 = (struct layerObj *)(argp1);
   28966           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   28967           0 :   if (!SWIG_IsOK(res2)) {
   28968           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByFilter" "', argument " "2"" of type '" "mapObj *""'"); 
   28969             :   }
   28970           0 :   arg2 = (mapObj *)(argp2);
   28971           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   28972           0 :   if (!SWIG_IsOK(res3)) {
   28973           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByFilter" "', argument " "3"" of type '" "char *""'");
   28974             :   }
   28975           0 :   arg3 = (char *)(buf3);
   28976             :   {
   28977           0 :     result = (int)layerObj_queryByFilter(arg1,arg2,arg3); {
   28978           0 :       errorObj *ms_error = msGetErrorObj();
   28979             :       
   28980           0 :       switch(ms_error->code) {
   28981             :       case MS_NOERR:
   28982             :         break;
   28983           0 :       case MS_NOTFOUND:
   28984           0 :         msResetErrorList();
   28985           0 :         break;
   28986             :       case -1:
   28987             :         break;
   28988           0 :       case MS_IOERR:
   28989           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   28990           0 :           _raise_ms_exception();
   28991           0 :           msResetErrorList();
   28992           0 :           return NULL;
   28993             :         }
   28994             :       default:
   28995           0 :         _raise_ms_exception();
   28996           0 :         msResetErrorList();
   28997           0 :         return NULL;
   28998             :       }
   28999             :       
   29000             :     }
   29001             :   }
   29002             :   resultobj = SWIG_From_int((int)(result));
   29003           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   29004             :   return resultobj;
   29005           0 : fail:
   29006           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   29007             :   return NULL;
   29008             : }
   29009             : 
   29010             : 
   29011           1 : SWIGINTERN PyObject *_wrap_layerObj_queryByAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29012             :   PyObject *resultobj = 0;
   29013             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29014             :   mapObj *arg2 = (mapObj *) 0 ;
   29015             :   char *arg3 = (char *) 0 ;
   29016             :   char *arg4 = (char *) 0 ;
   29017             :   int arg5 ;
   29018           1 :   void *argp1 = 0 ;
   29019             :   int res1 = 0 ;
   29020           1 :   void *argp2 = 0 ;
   29021             :   int res2 = 0 ;
   29022             :   int res3 ;
   29023           1 :   char *buf3 = 0 ;
   29024           1 :   int alloc3 = 0 ;
   29025             :   int res4 ;
   29026           1 :   char *buf4 = 0 ;
   29027           1 :   int alloc4 = 0 ;
   29028             :   int val5 ;
   29029             :   int ecode5 = 0 ;
   29030           1 :   PyObject * obj0 = 0 ;
   29031           1 :   PyObject * obj1 = 0 ;
   29032           1 :   PyObject * obj2 = 0 ;
   29033           1 :   PyObject * obj3 = 0 ;
   29034           1 :   PyObject * obj4 = 0 ;
   29035             :   int result;
   29036             :   
   29037           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:layerObj_queryByAttributes",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   29038           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29039           1 :   if (!SWIG_IsOK(res1)) {
   29040           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByAttributes" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29041             :   }
   29042           1 :   arg1 = (struct layerObj *)(argp1);
   29043           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   29044           1 :   if (!SWIG_IsOK(res2)) {
   29045           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByAttributes" "', argument " "2"" of type '" "mapObj *""'"); 
   29046             :   }
   29047           1 :   arg2 = (mapObj *)(argp2);
   29048           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   29049           1 :   if (!SWIG_IsOK(res3)) {
   29050           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByAttributes" "', argument " "3"" of type '" "char *""'");
   29051             :   }
   29052           1 :   arg3 = (char *)(buf3);
   29053           1 :   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
   29054           1 :   if (!SWIG_IsOK(res4)) {
   29055           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "layerObj_queryByAttributes" "', argument " "4"" of type '" "char *""'");
   29056             :   }
   29057           1 :   arg4 = (char *)(buf4);
   29058           1 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   29059           1 :   if (!SWIG_IsOK(ecode5)) {
   29060           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_queryByAttributes" "', argument " "5"" of type '" "int""'");
   29061             :   } 
   29062             :   arg5 = (int)(val5);
   29063             :   {
   29064           1 :     result = (int)layerObj_queryByAttributes(arg1,arg2,arg3,arg4,arg5); {
   29065           1 :       errorObj *ms_error = msGetErrorObj();
   29066             :       
   29067           1 :       switch(ms_error->code) {
   29068             :       case MS_NOERR:
   29069             :         break;
   29070           1 :       case MS_NOTFOUND:
   29071           1 :         msResetErrorList();
   29072           1 :         break;
   29073             :       case -1:
   29074             :         break;
   29075           0 :       case MS_IOERR:
   29076           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29077           0 :           _raise_ms_exception();
   29078           0 :           msResetErrorList();
   29079           0 :           return NULL;
   29080             :         }
   29081             :       default:
   29082           0 :         _raise_ms_exception();
   29083           0 :         msResetErrorList();
   29084           0 :         return NULL;
   29085             :       }
   29086             :       
   29087             :     }
   29088             :   }
   29089             :   resultobj = SWIG_From_int((int)(result));
   29090           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   29091           1 :   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
   29092             :   return resultobj;
   29093           0 : fail:
   29094           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   29095           0 :   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
   29096             :   return NULL;
   29097             : }
   29098             : 
   29099             : 
   29100           1 : SWIGINTERN PyObject *_wrap_layerObj_queryByPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29101             :   PyObject *resultobj = 0;
   29102             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29103             :   mapObj *arg2 = (mapObj *) 0 ;
   29104             :   pointObj *arg3 = (pointObj *) 0 ;
   29105             :   int arg4 ;
   29106             :   double arg5 ;
   29107           1 :   void *argp1 = 0 ;
   29108             :   int res1 = 0 ;
   29109           1 :   void *argp2 = 0 ;
   29110             :   int res2 = 0 ;
   29111           1 :   void *argp3 = 0 ;
   29112             :   int res3 = 0 ;
   29113             :   int val4 ;
   29114             :   int ecode4 = 0 ;
   29115             :   double val5 ;
   29116             :   int ecode5 = 0 ;
   29117           1 :   PyObject * obj0 = 0 ;
   29118           1 :   PyObject * obj1 = 0 ;
   29119           1 :   PyObject * obj2 = 0 ;
   29120           1 :   PyObject * obj3 = 0 ;
   29121           1 :   PyObject * obj4 = 0 ;
   29122             :   int result;
   29123             :   
   29124           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:layerObj_queryByPoint",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   29125           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29126           1 :   if (!SWIG_IsOK(res1)) {
   29127           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByPoint" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29128             :   }
   29129           1 :   arg1 = (struct layerObj *)(argp1);
   29130           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   29131           1 :   if (!SWIG_IsOK(res2)) {
   29132           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByPoint" "', argument " "2"" of type '" "mapObj *""'"); 
   29133             :   }
   29134           1 :   arg2 = (mapObj *)(argp2);
   29135           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 |  0 );
   29136           1 :   if (!SWIG_IsOK(res3)) {
   29137           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByPoint" "', argument " "3"" of type '" "pointObj *""'"); 
   29138             :   }
   29139           1 :   arg3 = (pointObj *)(argp3);
   29140           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   29141           1 :   if (!SWIG_IsOK(ecode4)) {
   29142           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_queryByPoint" "', argument " "4"" of type '" "int""'");
   29143             :   } 
   29144             :   arg4 = (int)(val4);
   29145           1 :   ecode5 = SWIG_AsVal_double(obj4, &val5);
   29146           1 :   if (!SWIG_IsOK(ecode5)) {
   29147           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_queryByPoint" "', argument " "5"" of type '" "double""'");
   29148             :   } 
   29149           1 :   arg5 = (double)(val5);
   29150             :   {
   29151             :     result = (int)layerObj_queryByPoint(arg1,arg2,arg3,arg4,arg5); {
   29152           1 :       errorObj *ms_error = msGetErrorObj();
   29153             :       
   29154           1 :       switch(ms_error->code) {
   29155             :       case MS_NOERR:
   29156             :         break;
   29157           1 :       case MS_NOTFOUND:
   29158           1 :         msResetErrorList();
   29159           1 :         break;
   29160             :       case -1:
   29161             :         break;
   29162           0 :       case MS_IOERR:
   29163           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29164           0 :           _raise_ms_exception();
   29165           0 :           msResetErrorList();
   29166           0 :           return NULL;
   29167             :         }
   29168             :       default:
   29169           0 :         _raise_ms_exception();
   29170           0 :         msResetErrorList();
   29171           0 :         return NULL;
   29172             :       }
   29173             :       
   29174             :     }
   29175             :   }
   29176             :   resultobj = SWIG_From_int((int)(result));
   29177           1 :   return resultobj;
   29178           0 : fail:
   29179             :   return NULL;
   29180             : }
   29181             : 
   29182             : 
   29183           1 : SWIGINTERN PyObject *_wrap_layerObj_queryByRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29184             :   PyObject *resultobj = 0;
   29185             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29186             :   mapObj *arg2 = (mapObj *) 0 ;
   29187             :   rectObj arg3 ;
   29188           1 :   void *argp1 = 0 ;
   29189             :   int res1 = 0 ;
   29190           1 :   void *argp2 = 0 ;
   29191             :   int res2 = 0 ;
   29192             :   void *argp3 ;
   29193             :   int res3 = 0 ;
   29194           1 :   PyObject * obj0 = 0 ;
   29195           1 :   PyObject * obj1 = 0 ;
   29196           1 :   PyObject * obj2 = 0 ;
   29197             :   int result;
   29198             :   
   29199           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByRect",&obj0,&obj1,&obj2)) SWIG_fail;
   29200           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29201           1 :   if (!SWIG_IsOK(res1)) {
   29202           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByRect" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29203             :   }
   29204           1 :   arg1 = (struct layerObj *)(argp1);
   29205           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   29206           1 :   if (!SWIG_IsOK(res2)) {
   29207           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByRect" "', argument " "2"" of type '" "mapObj *""'"); 
   29208             :   }
   29209           1 :   arg2 = (mapObj *)(argp2);
   29210             :   {
   29211           1 :     res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_rectObj,  0 );
   29212           1 :     if (!SWIG_IsOK(res3)) {
   29213           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByRect" "', argument " "3"" of type '" "rectObj""'"); 
   29214             :     }  
   29215           1 :     if (!argp3) {
   29216             :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "layerObj_queryByRect" "', argument " "3"" of type '" "rectObj""'");
   29217             :     } else {
   29218           1 :       arg3 = *((rectObj *)(argp3));
   29219             :     }
   29220             :   }
   29221             :   {
   29222             :     result = (int)layerObj_queryByRect(arg1,arg2,arg3); {
   29223           1 :       errorObj *ms_error = msGetErrorObj();
   29224             :       
   29225           1 :       switch(ms_error->code) {
   29226             :       case MS_NOERR:
   29227             :         break;
   29228           1 :       case MS_NOTFOUND:
   29229           1 :         msResetErrorList();
   29230           1 :         break;
   29231             :       case -1:
   29232             :         break;
   29233           0 :       case MS_IOERR:
   29234           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29235           0 :           _raise_ms_exception();
   29236           0 :           msResetErrorList();
   29237           0 :           return NULL;
   29238             :         }
   29239             :       default:
   29240           0 :         _raise_ms_exception();
   29241           0 :         msResetErrorList();
   29242           0 :         return NULL;
   29243             :       }
   29244             :       
   29245             :     }
   29246             :   }
   29247             :   resultobj = SWIG_From_int((int)(result));
   29248           1 :   return resultobj;
   29249           0 : fail:
   29250             :   return NULL;
   29251             : }
   29252             : 
   29253             : 
   29254           0 : SWIGINTERN PyObject *_wrap_layerObj_queryByFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29255             :   PyObject *resultobj = 0;
   29256             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29257             :   mapObj *arg2 = (mapObj *) 0 ;
   29258             :   int arg3 ;
   29259           0 :   void *argp1 = 0 ;
   29260             :   int res1 = 0 ;
   29261           0 :   void *argp2 = 0 ;
   29262             :   int res2 = 0 ;
   29263             :   int val3 ;
   29264             :   int ecode3 = 0 ;
   29265           0 :   PyObject * obj0 = 0 ;
   29266           0 :   PyObject * obj1 = 0 ;
   29267           0 :   PyObject * obj2 = 0 ;
   29268             :   int result;
   29269             :   
   29270           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByFeatures",&obj0,&obj1,&obj2)) SWIG_fail;
   29271           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29272           0 :   if (!SWIG_IsOK(res1)) {
   29273           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByFeatures" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29274             :   }
   29275           0 :   arg1 = (struct layerObj *)(argp1);
   29276           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   29277           0 :   if (!SWIG_IsOK(res2)) {
   29278           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByFeatures" "', argument " "2"" of type '" "mapObj *""'"); 
   29279             :   }
   29280           0 :   arg2 = (mapObj *)(argp2);
   29281           0 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   29282           0 :   if (!SWIG_IsOK(ecode3)) {
   29283           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_queryByFeatures" "', argument " "3"" of type '" "int""'");
   29284             :   } 
   29285             :   arg3 = (int)(val3);
   29286             :   {
   29287           0 :     result = (int)layerObj_queryByFeatures(arg1,arg2,arg3); {
   29288           0 :       errorObj *ms_error = msGetErrorObj();
   29289             :       
   29290           0 :       switch(ms_error->code) {
   29291             :       case MS_NOERR:
   29292             :         break;
   29293           0 :       case MS_NOTFOUND:
   29294           0 :         msResetErrorList();
   29295           0 :         break;
   29296             :       case -1:
   29297             :         break;
   29298           0 :       case MS_IOERR:
   29299           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29300           0 :           _raise_ms_exception();
   29301           0 :           msResetErrorList();
   29302           0 :           return NULL;
   29303             :         }
   29304             :       default:
   29305           0 :         _raise_ms_exception();
   29306           0 :         msResetErrorList();
   29307           0 :         return NULL;
   29308             :       }
   29309             :       
   29310             :     }
   29311             :   }
   29312             :   resultobj = SWIG_From_int((int)(result));
   29313           0 :   return resultobj;
   29314           0 : fail:
   29315             :   return NULL;
   29316             : }
   29317             : 
   29318             : 
   29319           1 : SWIGINTERN PyObject *_wrap_layerObj_queryByShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29320             :   PyObject *resultobj = 0;
   29321             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29322             :   mapObj *arg2 = (mapObj *) 0 ;
   29323             :   shapeObj *arg3 = (shapeObj *) 0 ;
   29324           1 :   void *argp1 = 0 ;
   29325             :   int res1 = 0 ;
   29326           1 :   void *argp2 = 0 ;
   29327             :   int res2 = 0 ;
   29328           1 :   void *argp3 = 0 ;
   29329             :   int res3 = 0 ;
   29330           1 :   PyObject * obj0 = 0 ;
   29331           1 :   PyObject * obj1 = 0 ;
   29332           1 :   PyObject * obj2 = 0 ;
   29333             :   int result;
   29334             :   
   29335           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByShape",&obj0,&obj1,&obj2)) SWIG_fail;
   29336           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29337           1 :   if (!SWIG_IsOK(res1)) {
   29338           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByShape" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29339             :   }
   29340           1 :   arg1 = (struct layerObj *)(argp1);
   29341           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   29342           1 :   if (!SWIG_IsOK(res2)) {
   29343           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByShape" "', argument " "2"" of type '" "mapObj *""'"); 
   29344             :   }
   29345           1 :   arg2 = (mapObj *)(argp2);
   29346           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_shapeObj, 0 |  0 );
   29347           1 :   if (!SWIG_IsOK(res3)) {
   29348           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByShape" "', argument " "3"" of type '" "shapeObj *""'"); 
   29349             :   }
   29350           1 :   arg3 = (shapeObj *)(argp3);
   29351             :   {
   29352           1 :     result = (int)layerObj_queryByShape(arg1,arg2,arg3); {
   29353           1 :       errorObj *ms_error = msGetErrorObj();
   29354             :       
   29355           1 :       switch(ms_error->code) {
   29356             :       case MS_NOERR:
   29357             :         break;
   29358           1 :       case MS_NOTFOUND:
   29359           1 :         msResetErrorList();
   29360           1 :         break;
   29361             :       case -1:
   29362             :         break;
   29363           0 :       case MS_IOERR:
   29364           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29365           0 :           _raise_ms_exception();
   29366           0 :           msResetErrorList();
   29367           0 :           return NULL;
   29368             :         }
   29369             :       default:
   29370           0 :         _raise_ms_exception();
   29371           0 :         msResetErrorList();
   29372           0 :         return NULL;
   29373             :       }
   29374             :       
   29375             :     }
   29376             :   }
   29377             :   resultobj = SWIG_From_int((int)(result));
   29378           1 :   return resultobj;
   29379           0 : fail:
   29380             :   return NULL;
   29381             : }
   29382             : 
   29383             : 
   29384           1 : SWIGINTERN PyObject *_wrap_layerObj_queryByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29385             :   PyObject *resultobj = 0;
   29386             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29387             :   mapObj *arg2 = (mapObj *) 0 ;
   29388             :   int arg3 ;
   29389             :   int arg4 ;
   29390             :   int arg5 = (int) 0 ;
   29391           1 :   void *argp1 = 0 ;
   29392             :   int res1 = 0 ;
   29393           1 :   void *argp2 = 0 ;
   29394             :   int res2 = 0 ;
   29395             :   int val3 ;
   29396             :   int ecode3 = 0 ;
   29397             :   int val4 ;
   29398             :   int ecode4 = 0 ;
   29399             :   int val5 ;
   29400             :   int ecode5 = 0 ;
   29401           1 :   PyObject * obj0 = 0 ;
   29402           1 :   PyObject * obj1 = 0 ;
   29403           1 :   PyObject * obj2 = 0 ;
   29404           1 :   PyObject * obj3 = 0 ;
   29405           1 :   PyObject * obj4 = 0 ;
   29406             :   int result;
   29407             :   
   29408           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOO|O:layerObj_queryByIndex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   29409           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29410           1 :   if (!SWIG_IsOK(res1)) {
   29411           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByIndex" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29412             :   }
   29413           1 :   arg1 = (struct layerObj *)(argp1);
   29414           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   29415           1 :   if (!SWIG_IsOK(res2)) {
   29416           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByIndex" "', argument " "2"" of type '" "mapObj *""'"); 
   29417             :   }
   29418           1 :   arg2 = (mapObj *)(argp2);
   29419           1 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   29420           1 :   if (!SWIG_IsOK(ecode3)) {
   29421           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_queryByIndex" "', argument " "3"" of type '" "int""'");
   29422             :   } 
   29423             :   arg3 = (int)(val3);
   29424           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   29425           1 :   if (!SWIG_IsOK(ecode4)) {
   29426           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_queryByIndex" "', argument " "4"" of type '" "int""'");
   29427             :   } 
   29428             :   arg4 = (int)(val4);
   29429           1 :   if (obj4) {
   29430             :     ecode5 = SWIG_AsVal_int(obj4, &val5);
   29431           1 :     if (!SWIG_IsOK(ecode5)) {
   29432           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_queryByIndex" "', argument " "5"" of type '" "int""'");
   29433             :     } 
   29434             :     arg5 = (int)(val5);
   29435             :   }
   29436             :   {
   29437             :     result = (int)layerObj_queryByIndex(arg1,arg2,arg3,arg4,arg5); {
   29438           1 :       errorObj *ms_error = msGetErrorObj();
   29439             :       
   29440           1 :       switch(ms_error->code) {
   29441             :       case MS_NOERR:
   29442             :         break;
   29443           0 :       case MS_NOTFOUND:
   29444           0 :         msResetErrorList();
   29445           0 :         break;
   29446             :       case -1:
   29447             :         break;
   29448           0 :       case MS_IOERR:
   29449           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29450           0 :           _raise_ms_exception();
   29451           0 :           msResetErrorList();
   29452           0 :           return NULL;
   29453             :         }
   29454             :       default:
   29455           0 :         _raise_ms_exception();
   29456           0 :         msResetErrorList();
   29457           0 :         return NULL;
   29458             :       }
   29459             :       
   29460             :     }
   29461             :   }
   29462             :   resultobj = SWIG_From_int((int)(result));
   29463           1 :   return resultobj;
   29464           0 : fail:
   29465             :   return NULL;
   29466             : }
   29467             : 
   29468             : 
   29469           1 : SWIGINTERN PyObject *_wrap_layerObj_getResults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29470             :   PyObject *resultobj = 0;
   29471             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29472           1 :   void *argp1 = 0 ;
   29473             :   int res1 = 0 ;
   29474           1 :   PyObject * obj0 = 0 ;
   29475             :   resultCacheObj *result = 0 ;
   29476             :   
   29477           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getResults",&obj0)) SWIG_fail;
   29478           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29479           1 :   if (!SWIG_IsOK(res1)) {
   29480           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getResults" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29481             :   }
   29482           1 :   arg1 = (struct layerObj *)(argp1);
   29483             :   {
   29484           1 :     result = (resultCacheObj *)layerObj_getResults(arg1); {
   29485           1 :       errorObj *ms_error = msGetErrorObj();
   29486             :       
   29487           1 :       switch(ms_error->code) {
   29488             :       case MS_NOERR:
   29489             :         break;
   29490           0 :       case MS_NOTFOUND:
   29491           0 :         msResetErrorList();
   29492           0 :         break;
   29493             :       case -1:
   29494             :         break;
   29495           0 :       case MS_IOERR:
   29496           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29497           0 :           _raise_ms_exception();
   29498           0 :           msResetErrorList();
   29499           0 :           return NULL;
   29500             :         }
   29501             :       default:
   29502           0 :         _raise_ms_exception();
   29503           0 :         msResetErrorList();
   29504           0 :         return NULL;
   29505             :       }
   29506             :       
   29507             :     }
   29508             :   }
   29509           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultCacheObj, 0 |  0 );
   29510           1 :   return resultobj;
   29511           0 : fail:
   29512             :   return NULL;
   29513             : }
   29514             : 
   29515             : 
   29516           1 : SWIGINTERN PyObject *_wrap_layerObj_setFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29517             :   PyObject *resultobj = 0;
   29518             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29519             :   char *arg2 = (char *) 0 ;
   29520           1 :   void *argp1 = 0 ;
   29521             :   int res1 = 0 ;
   29522             :   int res2 ;
   29523           1 :   char *buf2 = 0 ;
   29524           1 :   int alloc2 = 0 ;
   29525           1 :   PyObject * obj0 = 0 ;
   29526           1 :   PyObject * obj1 = 0 ;
   29527             :   int result;
   29528             :   
   29529           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setFilter",&obj0,&obj1)) SWIG_fail;
   29530           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29531           1 :   if (!SWIG_IsOK(res1)) {
   29532           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setFilter" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29533             :   }
   29534           1 :   arg1 = (struct layerObj *)(argp1);
   29535           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   29536           1 :   if (!SWIG_IsOK(res2)) {
   29537           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setFilter" "', argument " "2"" of type '" "char *""'");
   29538             :   }
   29539           1 :   arg2 = (char *)(buf2);
   29540             :   {
   29541           1 :     result = (int)layerObj_setFilter(arg1,arg2); {
   29542           1 :       errorObj *ms_error = msGetErrorObj();
   29543             :       
   29544           1 :       switch(ms_error->code) {
   29545             :       case MS_NOERR:
   29546             :         break;
   29547           0 :       case MS_NOTFOUND:
   29548           0 :         msResetErrorList();
   29549           0 :         break;
   29550             :       case -1:
   29551             :         break;
   29552           0 :       case MS_IOERR:
   29553           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29554           0 :           _raise_ms_exception();
   29555           0 :           msResetErrorList();
   29556           0 :           return NULL;
   29557             :         }
   29558             :       default:
   29559           0 :         _raise_ms_exception();
   29560           0 :         msResetErrorList();
   29561           0 :         return NULL;
   29562             :       }
   29563             :       
   29564             :     }
   29565             :   }
   29566             :   resultobj = SWIG_From_int((int)(result));
   29567           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   29568             :   return resultobj;
   29569           0 : fail:
   29570           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   29571             :   return NULL;
   29572             : }
   29573             : 
   29574             : 
   29575           1 : SWIGINTERN PyObject *_wrap_layerObj_getFilterString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29576             :   PyObject *resultobj = 0;
   29577             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29578           1 :   void *argp1 = 0 ;
   29579             :   int res1 = 0 ;
   29580           1 :   PyObject * obj0 = 0 ;
   29581             :   char *result = 0 ;
   29582             :   
   29583           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getFilterString",&obj0)) SWIG_fail;
   29584           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29585           1 :   if (!SWIG_IsOK(res1)) {
   29586           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getFilterString" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29587             :   }
   29588           1 :   arg1 = (struct layerObj *)(argp1);
   29589             :   {
   29590             :     result = (char *)layerObj_getFilterString(arg1); {
   29591           1 :       errorObj *ms_error = msGetErrorObj();
   29592             :       
   29593           1 :       switch(ms_error->code) {
   29594             :       case MS_NOERR:
   29595             :         break;
   29596           0 :       case MS_NOTFOUND:
   29597           0 :         msResetErrorList();
   29598           0 :         break;
   29599             :       case -1:
   29600             :         break;
   29601           0 :       case MS_IOERR:
   29602           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29603           0 :           _raise_ms_exception();
   29604           0 :           msResetErrorList();
   29605           0 :           return NULL;
   29606             :         }
   29607             :       default:
   29608           0 :         _raise_ms_exception();
   29609           0 :         msResetErrorList();
   29610           0 :         return NULL;
   29611             :       }
   29612             :       
   29613             :     }
   29614             :   }
   29615           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   29616           1 :   free((char*)result);
   29617           1 :   return resultobj;
   29618           0 : fail:
   29619             :   return NULL;
   29620             : }
   29621             : 
   29622             : 
   29623           0 : SWIGINTERN PyObject *_wrap_layerObj_setWKTProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29624             :   PyObject *resultobj = 0;
   29625             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29626             :   char *arg2 = (char *) 0 ;
   29627           0 :   void *argp1 = 0 ;
   29628             :   int res1 = 0 ;
   29629             :   int res2 ;
   29630           0 :   char *buf2 = 0 ;
   29631           0 :   int alloc2 = 0 ;
   29632           0 :   PyObject * obj0 = 0 ;
   29633           0 :   PyObject * obj1 = 0 ;
   29634             :   int result;
   29635             :   
   29636           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setWKTProjection",&obj0,&obj1)) SWIG_fail;
   29637           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29638           0 :   if (!SWIG_IsOK(res1)) {
   29639           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setWKTProjection" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29640             :   }
   29641           0 :   arg1 = (struct layerObj *)(argp1);
   29642           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   29643           0 :   if (!SWIG_IsOK(res2)) {
   29644           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setWKTProjection" "', argument " "2"" of type '" "char *""'");
   29645             :   }
   29646           0 :   arg2 = (char *)(buf2);
   29647             :   {
   29648             :     result = (int)layerObj_setWKTProjection(arg1,arg2); {
   29649           0 :       errorObj *ms_error = msGetErrorObj();
   29650             :       
   29651           0 :       switch(ms_error->code) {
   29652             :       case MS_NOERR:
   29653             :         break;
   29654           0 :       case MS_NOTFOUND:
   29655           0 :         msResetErrorList();
   29656           0 :         break;
   29657             :       case -1:
   29658             :         break;
   29659           0 :       case MS_IOERR:
   29660           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29661           0 :           _raise_ms_exception();
   29662           0 :           msResetErrorList();
   29663           0 :           return NULL;
   29664             :         }
   29665             :       default:
   29666           0 :         _raise_ms_exception();
   29667           0 :         msResetErrorList();
   29668           0 :         return NULL;
   29669             :       }
   29670             :       
   29671             :     }
   29672             :   }
   29673             :   resultobj = SWIG_From_int((int)(result));
   29674           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   29675             :   return resultobj;
   29676           0 : fail:
   29677           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   29678             :   return NULL;
   29679             : }
   29680             : 
   29681             : 
   29682           0 : SWIGINTERN PyObject *_wrap_layerObj_getProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29683             :   PyObject *resultobj = 0;
   29684             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29685           0 :   void *argp1 = 0 ;
   29686             :   int res1 = 0 ;
   29687           0 :   PyObject * obj0 = 0 ;
   29688             :   char *result = 0 ;
   29689             :   
   29690           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getProjection",&obj0)) SWIG_fail;
   29691           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29692           0 :   if (!SWIG_IsOK(res1)) {
   29693           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getProjection" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29694             :   }
   29695           0 :   arg1 = (struct layerObj *)(argp1);
   29696             :   {
   29697             :     result = (char *)layerObj_getProjection(arg1); {
   29698           0 :       errorObj *ms_error = msGetErrorObj();
   29699             :       
   29700           0 :       switch(ms_error->code) {
   29701             :       case MS_NOERR:
   29702             :         break;
   29703           0 :       case MS_NOTFOUND:
   29704           0 :         msResetErrorList();
   29705           0 :         break;
   29706             :       case -1:
   29707             :         break;
   29708           0 :       case MS_IOERR:
   29709           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29710           0 :           _raise_ms_exception();
   29711           0 :           msResetErrorList();
   29712           0 :           return NULL;
   29713             :         }
   29714             :       default:
   29715           0 :         _raise_ms_exception();
   29716           0 :         msResetErrorList();
   29717           0 :         return NULL;
   29718             :       }
   29719             :       
   29720             :     }
   29721             :   }
   29722           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   29723           0 :   free((char*)result);
   29724           0 :   return resultobj;
   29725           0 : fail:
   29726             :   return NULL;
   29727             : }
   29728             : 
   29729             : 
   29730           1 : SWIGINTERN PyObject *_wrap_layerObj_setProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29731             :   PyObject *resultobj = 0;
   29732             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29733             :   char *arg2 = (char *) 0 ;
   29734           1 :   void *argp1 = 0 ;
   29735             :   int res1 = 0 ;
   29736             :   int res2 ;
   29737           1 :   char *buf2 = 0 ;
   29738           1 :   int alloc2 = 0 ;
   29739           1 :   PyObject * obj0 = 0 ;
   29740           1 :   PyObject * obj1 = 0 ;
   29741             :   int result;
   29742             :   
   29743           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setProjection",&obj0,&obj1)) SWIG_fail;
   29744           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29745           1 :   if (!SWIG_IsOK(res1)) {
   29746           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setProjection" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29747             :   }
   29748           1 :   arg1 = (struct layerObj *)(argp1);
   29749           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   29750           1 :   if (!SWIG_IsOK(res2)) {
   29751           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setProjection" "', argument " "2"" of type '" "char *""'");
   29752             :   }
   29753           1 :   arg2 = (char *)(buf2);
   29754             :   {
   29755             :     result = (int)layerObj_setProjection(arg1,arg2); {
   29756           1 :       errorObj *ms_error = msGetErrorObj();
   29757             :       
   29758           1 :       switch(ms_error->code) {
   29759             :       case MS_NOERR:
   29760             :         break;
   29761           0 :       case MS_NOTFOUND:
   29762           0 :         msResetErrorList();
   29763           0 :         break;
   29764             :       case -1:
   29765             :         break;
   29766           0 :       case MS_IOERR:
   29767           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29768           0 :           _raise_ms_exception();
   29769           0 :           msResetErrorList();
   29770           0 :           return NULL;
   29771             :         }
   29772             :       default:
   29773           0 :         _raise_ms_exception();
   29774           0 :         msResetErrorList();
   29775           0 :         return NULL;
   29776             :       }
   29777             :       
   29778             :     }
   29779             :   }
   29780             :   resultobj = SWIG_From_int((int)(result));
   29781           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   29782             :   return resultobj;
   29783           0 : fail:
   29784           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   29785             :   return NULL;
   29786             : }
   29787             : 
   29788             : 
   29789           1 : SWIGINTERN PyObject *_wrap_layerObj_addFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29790             :   PyObject *resultobj = 0;
   29791             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29792             :   shapeObj *arg2 = (shapeObj *) 0 ;
   29793           1 :   void *argp1 = 0 ;
   29794             :   int res1 = 0 ;
   29795           1 :   void *argp2 = 0 ;
   29796             :   int res2 = 0 ;
   29797           1 :   PyObject * obj0 = 0 ;
   29798           1 :   PyObject * obj1 = 0 ;
   29799             :   int result;
   29800             :   
   29801           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_addFeature",&obj0,&obj1)) SWIG_fail;
   29802           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29803           1 :   if (!SWIG_IsOK(res1)) {
   29804           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_addFeature" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29805             :   }
   29806           1 :   arg1 = (struct layerObj *)(argp1);
   29807           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   29808           1 :   if (!SWIG_IsOK(res2)) {
   29809           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_addFeature" "', argument " "2"" of type '" "shapeObj *""'"); 
   29810             :   }
   29811           1 :   arg2 = (shapeObj *)(argp2);
   29812             :   {
   29813           1 :     result = (int)layerObj_addFeature(arg1,arg2); {
   29814           1 :       errorObj *ms_error = msGetErrorObj();
   29815             :       
   29816           1 :       switch(ms_error->code) {
   29817             :       case MS_NOERR:
   29818             :         break;
   29819           0 :       case MS_NOTFOUND:
   29820           0 :         msResetErrorList();
   29821           0 :         break;
   29822             :       case -1:
   29823             :         break;
   29824           0 :       case MS_IOERR:
   29825           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29826           0 :           _raise_ms_exception();
   29827           0 :           msResetErrorList();
   29828           0 :           return NULL;
   29829             :         }
   29830             :       default:
   29831           0 :         _raise_ms_exception();
   29832           0 :         msResetErrorList();
   29833           0 :         return NULL;
   29834             :       }
   29835             :       
   29836             :     }
   29837             :   }
   29838             :   resultobj = SWIG_From_int((int)(result));
   29839           1 :   return resultobj;
   29840           0 : fail:
   29841             :   return NULL;
   29842             : }
   29843             : 
   29844             : 
   29845           1 : SWIGINTERN PyObject *_wrap_layerObj_getNumFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29846             :   PyObject *resultobj = 0;
   29847             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29848           1 :   void *argp1 = 0 ;
   29849             :   int res1 = 0 ;
   29850           1 :   PyObject * obj0 = 0 ;
   29851             :   int result;
   29852             :   
   29853           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getNumFeatures",&obj0)) SWIG_fail;
   29854           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29855           1 :   if (!SWIG_IsOK(res1)) {
   29856           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getNumFeatures" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29857             :   }
   29858           1 :   arg1 = (struct layerObj *)(argp1);
   29859             :   {
   29860             :     result = (int)layerObj_getNumFeatures(arg1); {
   29861           1 :       errorObj *ms_error = msGetErrorObj();
   29862             :       
   29863           1 :       switch(ms_error->code) {
   29864             :       case MS_NOERR:
   29865             :         break;
   29866           0 :       case MS_NOTFOUND:
   29867           0 :         msResetErrorList();
   29868           0 :         break;
   29869             :       case -1:
   29870             :         break;
   29871           0 :       case MS_IOERR:
   29872           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29873           0 :           _raise_ms_exception();
   29874           0 :           msResetErrorList();
   29875           0 :           return NULL;
   29876             :         }
   29877             :       default:
   29878           1 :         _raise_ms_exception();
   29879           1 :         msResetErrorList();
   29880           1 :         return NULL;
   29881             :       }
   29882             :       
   29883             :     }
   29884             :   }
   29885             :   resultobj = SWIG_From_int((int)(result));
   29886           1 :   return resultobj;
   29887           0 : fail:
   29888             :   return NULL;
   29889             : }
   29890             : 
   29891             : 
   29892           1 : SWIGINTERN PyObject *_wrap_layerObj_getExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29893             :   PyObject *resultobj = 0;
   29894             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29895           1 :   void *argp1 = 0 ;
   29896             :   int res1 = 0 ;
   29897           1 :   PyObject * obj0 = 0 ;
   29898             :   rectObj *result = 0 ;
   29899             :   
   29900           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getExtent",&obj0)) SWIG_fail;
   29901           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29902           1 :   if (!SWIG_IsOK(res1)) {
   29903           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getExtent" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29904             :   }
   29905           1 :   arg1 = (struct layerObj *)(argp1);
   29906             :   {
   29907             :     result = (rectObj *)layerObj_getExtent(arg1); {
   29908           1 :       errorObj *ms_error = msGetErrorObj();
   29909             :       
   29910           1 :       switch(ms_error->code) {
   29911             :       case MS_NOERR:
   29912             :         break;
   29913           0 :       case MS_NOTFOUND:
   29914           0 :         msResetErrorList();
   29915           0 :         break;
   29916             :       case -1:
   29917             :         break;
   29918           0 :       case MS_IOERR:
   29919           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   29920           0 :           _raise_ms_exception();
   29921           0 :           msResetErrorList();
   29922           0 :           return NULL;
   29923             :         }
   29924             :       default:
   29925           0 :         _raise_ms_exception();
   29926           0 :         msResetErrorList();
   29927           0 :         return NULL;
   29928             :       }
   29929             :       
   29930             :     }
   29931             :   }
   29932           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, SWIG_POINTER_OWN |  0 );
   29933           1 :   return resultobj;
   29934           0 : fail:
   29935             :   return NULL;
   29936             : }
   29937             : 
   29938             : 
   29939           1 : SWIGINTERN PyObject *_wrap_layerObj_setExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   29940             :   PyObject *resultobj = 0;
   29941             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   29942             :   double arg2 = (double) -1.0 ;
   29943             :   double arg3 = (double) -1.0 ;
   29944             :   double arg4 = (double) -1.0 ;
   29945             :   double arg5 = (double) -1.0 ;
   29946           1 :   void *argp1 = 0 ;
   29947             :   int res1 = 0 ;
   29948             :   double val2 ;
   29949             :   int ecode2 = 0 ;
   29950             :   double val3 ;
   29951             :   int ecode3 = 0 ;
   29952             :   double val4 ;
   29953             :   int ecode4 = 0 ;
   29954             :   double val5 ;
   29955             :   int ecode5 = 0 ;
   29956           1 :   PyObject * obj0 = 0 ;
   29957           1 :   PyObject * obj1 = 0 ;
   29958           1 :   PyObject * obj2 = 0 ;
   29959           1 :   PyObject * obj3 = 0 ;
   29960           1 :   PyObject * obj4 = 0 ;
   29961             :   int result;
   29962             :   
   29963           1 :   if (!PyArg_ParseTuple(args,(char *)"O|OOOO:layerObj_setExtent",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   29964           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   29965           1 :   if (!SWIG_IsOK(res1)) {
   29966           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setExtent" "', argument " "1"" of type '" "struct layerObj *""'"); 
   29967             :   }
   29968           1 :   arg1 = (struct layerObj *)(argp1);
   29969           1 :   if (obj1) {
   29970           1 :     ecode2 = SWIG_AsVal_double(obj1, &val2);
   29971           1 :     if (!SWIG_IsOK(ecode2)) {
   29972           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_setExtent" "', argument " "2"" of type '" "double""'");
   29973             :     } 
   29974           1 :     arg2 = (double)(val2);
   29975             :   }
   29976           1 :   if (obj2) {
   29977           1 :     ecode3 = SWIG_AsVal_double(obj2, &val3);
   29978           1 :     if (!SWIG_IsOK(ecode3)) {
   29979           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_setExtent" "', argument " "3"" of type '" "double""'");
   29980             :     } 
   29981           1 :     arg3 = (double)(val3);
   29982             :   }
   29983           1 :   if (obj3) {
   29984           1 :     ecode4 = SWIG_AsVal_double(obj3, &val4);
   29985           1 :     if (!SWIG_IsOK(ecode4)) {
   29986           0 :       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_setExtent" "', argument " "4"" of type '" "double""'");
   29987             :     } 
   29988           1 :     arg4 = (double)(val4);
   29989             :   }
   29990           1 :   if (obj4) {
   29991           1 :     ecode5 = SWIG_AsVal_double(obj4, &val5);
   29992           1 :     if (!SWIG_IsOK(ecode5)) {
   29993           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_setExtent" "', argument " "5"" of type '" "double""'");
   29994             :     } 
   29995           1 :     arg5 = (double)(val5);
   29996             :   }
   29997             :   {
   29998           1 :     result = (int)layerObj_setExtent(arg1,arg2,arg3,arg4,arg5); {
   29999           1 :       errorObj *ms_error = msGetErrorObj();
   30000             :       
   30001           1 :       switch(ms_error->code) {
   30002             :       case MS_NOERR:
   30003             :         break;
   30004           0 :       case MS_NOTFOUND:
   30005           0 :         msResetErrorList();
   30006           0 :         break;
   30007             :       case -1:
   30008             :         break;
   30009           0 :       case MS_IOERR:
   30010           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30011           0 :           _raise_ms_exception();
   30012           0 :           msResetErrorList();
   30013           0 :           return NULL;
   30014             :         }
   30015             :       default:
   30016           0 :         _raise_ms_exception();
   30017           0 :         msResetErrorList();
   30018           0 :         return NULL;
   30019             :       }
   30020             :       
   30021             :     }
   30022             :   }
   30023             :   resultobj = SWIG_From_int((int)(result));
   30024           1 :   return resultobj;
   30025           0 : fail:
   30026             :   return NULL;
   30027             : }
   30028             : 
   30029             : 
   30030           0 : SWIGINTERN PyObject *_wrap_layerObj_getMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30031             :   PyObject *resultobj = 0;
   30032             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30033             :   char *arg2 = (char *) 0 ;
   30034           0 :   void *argp1 = 0 ;
   30035             :   int res1 = 0 ;
   30036             :   int res2 ;
   30037           0 :   char *buf2 = 0 ;
   30038           0 :   int alloc2 = 0 ;
   30039           0 :   PyObject * obj0 = 0 ;
   30040           0 :   PyObject * obj1 = 0 ;
   30041             :   char *result = 0 ;
   30042             :   
   30043           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getMetaData",&obj0,&obj1)) SWIG_fail;
   30044           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30045           0 :   if (!SWIG_IsOK(res1)) {
   30046           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getMetaData" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30047             :   }
   30048           0 :   arg1 = (struct layerObj *)(argp1);
   30049           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30050           0 :   if (!SWIG_IsOK(res2)) {
   30051           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getMetaData" "', argument " "2"" of type '" "char *""'");
   30052             :   }
   30053           0 :   arg2 = (char *)(buf2);
   30054             :   {
   30055           0 :     result = (char *)layerObj_getMetaData(arg1,arg2); {
   30056           0 :       errorObj *ms_error = msGetErrorObj();
   30057             :       
   30058           0 :       switch(ms_error->code) {
   30059             :       case MS_NOERR:
   30060             :         break;
   30061           0 :       case MS_NOTFOUND:
   30062           0 :         msResetErrorList();
   30063           0 :         break;
   30064             :       case -1:
   30065             :         break;
   30066           0 :       case MS_IOERR:
   30067           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30068           0 :           _raise_ms_exception();
   30069           0 :           msResetErrorList();
   30070           0 :           return NULL;
   30071             :         }
   30072             :       default:
   30073           0 :         _raise_ms_exception();
   30074           0 :         msResetErrorList();
   30075           0 :         return NULL;
   30076             :       }
   30077             :       
   30078             :     }
   30079             :   }
   30080           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   30081           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30082             :   return resultobj;
   30083           0 : fail:
   30084           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30085             :   return NULL;
   30086             : }
   30087             : 
   30088             : 
   30089           0 : SWIGINTERN PyObject *_wrap_layerObj_setMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30090             :   PyObject *resultobj = 0;
   30091             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30092             :   char *arg2 = (char *) 0 ;
   30093             :   char *arg3 = (char *) 0 ;
   30094           0 :   void *argp1 = 0 ;
   30095             :   int res1 = 0 ;
   30096             :   int res2 ;
   30097           0 :   char *buf2 = 0 ;
   30098           0 :   int alloc2 = 0 ;
   30099             :   int res3 ;
   30100           0 :   char *buf3 = 0 ;
   30101           0 :   int alloc3 = 0 ;
   30102           0 :   PyObject * obj0 = 0 ;
   30103           0 :   PyObject * obj1 = 0 ;
   30104           0 :   PyObject * obj2 = 0 ;
   30105             :   int result;
   30106             :   
   30107           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setMetaData",&obj0,&obj1,&obj2)) SWIG_fail;
   30108           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30109           0 :   if (!SWIG_IsOK(res1)) {
   30110           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setMetaData" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30111             :   }
   30112           0 :   arg1 = (struct layerObj *)(argp1);
   30113           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30114           0 :   if (!SWIG_IsOK(res2)) {
   30115           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setMetaData" "', argument " "2"" of type '" "char *""'");
   30116             :   }
   30117           0 :   arg2 = (char *)(buf2);
   30118           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   30119           0 :   if (!SWIG_IsOK(res3)) {
   30120           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_setMetaData" "', argument " "3"" of type '" "char *""'");
   30121             :   }
   30122           0 :   arg3 = (char *)(buf3);
   30123             :   {
   30124             :     result = (int)layerObj_setMetaData(arg1,arg2,arg3); {
   30125           0 :       errorObj *ms_error = msGetErrorObj();
   30126             :       
   30127           0 :       switch(ms_error->code) {
   30128             :       case MS_NOERR:
   30129             :         break;
   30130           0 :       case MS_NOTFOUND:
   30131           0 :         msResetErrorList();
   30132           0 :         break;
   30133             :       case -1:
   30134             :         break;
   30135           0 :       case MS_IOERR:
   30136           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30137           0 :           _raise_ms_exception();
   30138           0 :           msResetErrorList();
   30139           0 :           return NULL;
   30140             :         }
   30141             :       default:
   30142           0 :         _raise_ms_exception();
   30143           0 :         msResetErrorList();
   30144           0 :         return NULL;
   30145             :       }
   30146             :       
   30147             :     }
   30148             :   }
   30149             :   resultobj = SWIG_From_int((int)(result));
   30150           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30151           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30152             :   return resultobj;
   30153           0 : fail:
   30154           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30155           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30156             :   return NULL;
   30157             : }
   30158             : 
   30159             : 
   30160           0 : SWIGINTERN PyObject *_wrap_layerObj_removeMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30161             :   PyObject *resultobj = 0;
   30162             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30163             :   char *arg2 = (char *) 0 ;
   30164           0 :   void *argp1 = 0 ;
   30165             :   int res1 = 0 ;
   30166             :   int res2 ;
   30167           0 :   char *buf2 = 0 ;
   30168           0 :   int alloc2 = 0 ;
   30169           0 :   PyObject * obj0 = 0 ;
   30170           0 :   PyObject * obj1 = 0 ;
   30171             :   int result;
   30172             :   
   30173           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_removeMetaData",&obj0,&obj1)) SWIG_fail;
   30174           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30175           0 :   if (!SWIG_IsOK(res1)) {
   30176           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_removeMetaData" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30177             :   }
   30178           0 :   arg1 = (struct layerObj *)(argp1);
   30179           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30180           0 :   if (!SWIG_IsOK(res2)) {
   30181           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_removeMetaData" "', argument " "2"" of type '" "char *""'");
   30182             :   }
   30183           0 :   arg2 = (char *)(buf2);
   30184             :   {
   30185             :     result = (int)layerObj_removeMetaData(arg1,arg2); {
   30186           0 :       errorObj *ms_error = msGetErrorObj();
   30187             :       
   30188           0 :       switch(ms_error->code) {
   30189             :       case MS_NOERR:
   30190             :         break;
   30191           0 :       case MS_NOTFOUND:
   30192           0 :         msResetErrorList();
   30193           0 :         break;
   30194             :       case -1:
   30195             :         break;
   30196           0 :       case MS_IOERR:
   30197           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30198           0 :           _raise_ms_exception();
   30199           0 :           msResetErrorList();
   30200           0 :           return NULL;
   30201             :         }
   30202             :       default:
   30203           0 :         _raise_ms_exception();
   30204           0 :         msResetErrorList();
   30205           0 :         return NULL;
   30206             :       }
   30207             :       
   30208             :     }
   30209             :   }
   30210             :   resultobj = SWIG_From_int((int)(result));
   30211           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30212             :   return resultobj;
   30213           0 : fail:
   30214           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30215             :   return NULL;
   30216             : }
   30217             : 
   30218             : 
   30219           1 : SWIGINTERN PyObject *_wrap_layerObj_getFirstMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30220             :   PyObject *resultobj = 0;
   30221             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30222           1 :   void *argp1 = 0 ;
   30223             :   int res1 = 0 ;
   30224           1 :   PyObject * obj0 = 0 ;
   30225             :   char *result = 0 ;
   30226             :   
   30227           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getFirstMetaDataKey",&obj0)) SWIG_fail;
   30228           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30229           1 :   if (!SWIG_IsOK(res1)) {
   30230           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getFirstMetaDataKey" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30231             :   }
   30232           1 :   arg1 = (struct layerObj *)(argp1);
   30233             :   {
   30234             :     result = (char *)layerObj_getFirstMetaDataKey(arg1); {
   30235           1 :       errorObj *ms_error = msGetErrorObj();
   30236             :       
   30237           1 :       switch(ms_error->code) {
   30238             :       case MS_NOERR:
   30239             :         break;
   30240           0 :       case MS_NOTFOUND:
   30241           0 :         msResetErrorList();
   30242           0 :         break;
   30243             :       case -1:
   30244             :         break;
   30245           0 :       case MS_IOERR:
   30246           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30247           0 :           _raise_ms_exception();
   30248           0 :           msResetErrorList();
   30249           0 :           return NULL;
   30250             :         }
   30251             :       default:
   30252           0 :         _raise_ms_exception();
   30253           0 :         msResetErrorList();
   30254           0 :         return NULL;
   30255             :       }
   30256             :       
   30257             :     }
   30258             :   }
   30259           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   30260           1 :   return resultobj;
   30261           0 : fail:
   30262             :   return NULL;
   30263             : }
   30264             : 
   30265             : 
   30266           1 : SWIGINTERN PyObject *_wrap_layerObj_getNextMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30267             :   PyObject *resultobj = 0;
   30268             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30269             :   char *arg2 = (char *) 0 ;
   30270           1 :   void *argp1 = 0 ;
   30271             :   int res1 = 0 ;
   30272             :   int res2 ;
   30273           1 :   char *buf2 = 0 ;
   30274           1 :   int alloc2 = 0 ;
   30275           1 :   PyObject * obj0 = 0 ;
   30276           1 :   PyObject * obj1 = 0 ;
   30277             :   char *result = 0 ;
   30278             :   
   30279           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getNextMetaDataKey",&obj0,&obj1)) SWIG_fail;
   30280           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30281           1 :   if (!SWIG_IsOK(res1)) {
   30282           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getNextMetaDataKey" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30283             :   }
   30284           1 :   arg1 = (struct layerObj *)(argp1);
   30285           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30286           1 :   if (!SWIG_IsOK(res2)) {
   30287           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getNextMetaDataKey" "', argument " "2"" of type '" "char *""'");
   30288             :   }
   30289           1 :   arg2 = (char *)(buf2);
   30290             :   {
   30291             :     result = (char *)layerObj_getNextMetaDataKey(arg1,arg2); {
   30292           1 :       errorObj *ms_error = msGetErrorObj();
   30293             :       
   30294           1 :       switch(ms_error->code) {
   30295             :       case MS_NOERR:
   30296             :         break;
   30297           0 :       case MS_NOTFOUND:
   30298           0 :         msResetErrorList();
   30299           0 :         break;
   30300             :       case -1:
   30301             :         break;
   30302           0 :       case MS_IOERR:
   30303           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30304           0 :           _raise_ms_exception();
   30305           0 :           msResetErrorList();
   30306           0 :           return NULL;
   30307             :         }
   30308             :       default:
   30309           0 :         _raise_ms_exception();
   30310           0 :         msResetErrorList();
   30311           0 :         return NULL;
   30312             :       }
   30313             :       
   30314             :     }
   30315             :   }
   30316           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   30317           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30318             :   return resultobj;
   30319           0 : fail:
   30320           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30321             :   return NULL;
   30322             : }
   30323             : 
   30324             : 
   30325           0 : SWIGINTERN PyObject *_wrap_layerObj_getWMSFeatureInfoURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30326             :   PyObject *resultobj = 0;
   30327             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30328             :   mapObj *arg2 = (mapObj *) 0 ;
   30329             :   int arg3 ;
   30330             :   int arg4 ;
   30331             :   int arg5 ;
   30332             :   char *arg6 = (char *) 0 ;
   30333           0 :   void *argp1 = 0 ;
   30334             :   int res1 = 0 ;
   30335           0 :   void *argp2 = 0 ;
   30336             :   int res2 = 0 ;
   30337             :   int val3 ;
   30338             :   int ecode3 = 0 ;
   30339             :   int val4 ;
   30340             :   int ecode4 = 0 ;
   30341             :   int val5 ;
   30342             :   int ecode5 = 0 ;
   30343             :   int res6 ;
   30344           0 :   char *buf6 = 0 ;
   30345           0 :   int alloc6 = 0 ;
   30346           0 :   PyObject * obj0 = 0 ;
   30347           0 :   PyObject * obj1 = 0 ;
   30348           0 :   PyObject * obj2 = 0 ;
   30349           0 :   PyObject * obj3 = 0 ;
   30350           0 :   PyObject * obj4 = 0 ;
   30351           0 :   PyObject * obj5 = 0 ;
   30352             :   char *result = 0 ;
   30353             :   
   30354           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:layerObj_getWMSFeatureInfoURL",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   30355           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30356           0 :   if (!SWIG_IsOK(res1)) {
   30357           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30358             :   }
   30359           0 :   arg1 = (struct layerObj *)(argp1);
   30360           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   30361           0 :   if (!SWIG_IsOK(res2)) {
   30362           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "2"" of type '" "mapObj *""'"); 
   30363             :   }
   30364           0 :   arg2 = (mapObj *)(argp2);
   30365           0 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   30366           0 :   if (!SWIG_IsOK(ecode3)) {
   30367           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "3"" of type '" "int""'");
   30368             :   } 
   30369             :   arg3 = (int)(val3);
   30370           0 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   30371           0 :   if (!SWIG_IsOK(ecode4)) {
   30372           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "4"" of type '" "int""'");
   30373             :   } 
   30374             :   arg4 = (int)(val4);
   30375           0 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   30376           0 :   if (!SWIG_IsOK(ecode5)) {
   30377           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "5"" of type '" "int""'");
   30378             :   } 
   30379             :   arg5 = (int)(val5);
   30380           0 :   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
   30381           0 :   if (!SWIG_IsOK(res6)) {
   30382           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "6"" of type '" "char *""'");
   30383             :   }
   30384           0 :   arg6 = (char *)(buf6);
   30385             :   {
   30386             :     result = (char *)layerObj_getWMSFeatureInfoURL(arg1,arg2,arg3,arg4,arg5,arg6); {
   30387           0 :       errorObj *ms_error = msGetErrorObj();
   30388             :       
   30389           0 :       switch(ms_error->code) {
   30390             :       case MS_NOERR:
   30391             :         break;
   30392           0 :       case MS_NOTFOUND:
   30393           0 :         msResetErrorList();
   30394           0 :         break;
   30395             :       case -1:
   30396             :         break;
   30397           0 :       case MS_IOERR:
   30398           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30399           0 :           _raise_ms_exception();
   30400           0 :           msResetErrorList();
   30401           0 :           return NULL;
   30402             :         }
   30403             :       default:
   30404           0 :         _raise_ms_exception();
   30405           0 :         msResetErrorList();
   30406           0 :         return NULL;
   30407             :       }
   30408             :       
   30409             :     }
   30410             :   }
   30411           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   30412           0 :   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
   30413           0 :   free((char*)result);
   30414           0 :   return resultobj;
   30415           0 : fail:
   30416           0 :   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
   30417             :   return NULL;
   30418             : }
   30419             : 
   30420             : 
   30421           0 : SWIGINTERN PyObject *_wrap_layerObj_executeWFSGetFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30422             :   PyObject *resultobj = 0;
   30423             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30424             :   layerObj *arg2 = (layerObj *) 0 ;
   30425           0 :   void *argp1 = 0 ;
   30426             :   int res1 = 0 ;
   30427           0 :   void *argp2 = 0 ;
   30428             :   int res2 = 0 ;
   30429           0 :   PyObject * obj0 = 0 ;
   30430           0 :   PyObject * obj1 = 0 ;
   30431             :   char *result = 0 ;
   30432             :   
   30433           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_executeWFSGetFeature",&obj0,&obj1)) SWIG_fail;
   30434           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30435           0 :   if (!SWIG_IsOK(res1)) {
   30436           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_executeWFSGetFeature" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30437             :   }
   30438             :   arg1 = (struct layerObj *)(argp1);
   30439           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_layerObj, 0 |  0 );
   30440           0 :   if (!SWIG_IsOK(res2)) {
   30441           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_executeWFSGetFeature" "', argument " "2"" of type '" "layerObj *""'"); 
   30442             :   }
   30443           0 :   arg2 = (layerObj *)(argp2);
   30444             :   {
   30445             :     result = (char *)layerObj_executeWFSGetFeature(arg1,arg2); {
   30446           0 :       errorObj *ms_error = msGetErrorObj();
   30447             :       
   30448           0 :       switch(ms_error->code) {
   30449             :       case MS_NOERR:
   30450             :         break;
   30451           0 :       case MS_NOTFOUND:
   30452           0 :         msResetErrorList();
   30453           0 :         break;
   30454             :       case -1:
   30455             :         break;
   30456           0 :       case MS_IOERR:
   30457           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30458           0 :           _raise_ms_exception();
   30459           0 :           msResetErrorList();
   30460           0 :           return NULL;
   30461             :         }
   30462             :       default:
   30463           0 :         _raise_ms_exception();
   30464           0 :         msResetErrorList();
   30465           0 :         return NULL;
   30466             :       }
   30467             :       
   30468             :     }
   30469             :   }
   30470           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   30471           0 :   free((char*)result);
   30472           0 :   return resultobj;
   30473           0 : fail:
   30474             :   return NULL;
   30475             : }
   30476             : 
   30477             : 
   30478           0 : SWIGINTERN PyObject *_wrap_layerObj_applySLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30479             :   PyObject *resultobj = 0;
   30480             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30481             :   char *arg2 = (char *) 0 ;
   30482             :   char *arg3 = (char *) 0 ;
   30483           0 :   void *argp1 = 0 ;
   30484             :   int res1 = 0 ;
   30485             :   int res2 ;
   30486           0 :   char *buf2 = 0 ;
   30487           0 :   int alloc2 = 0 ;
   30488             :   int res3 ;
   30489           0 :   char *buf3 = 0 ;
   30490           0 :   int alloc3 = 0 ;
   30491           0 :   PyObject * obj0 = 0 ;
   30492           0 :   PyObject * obj1 = 0 ;
   30493           0 :   PyObject * obj2 = 0 ;
   30494             :   int result;
   30495             :   
   30496           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_applySLD",&obj0,&obj1,&obj2)) SWIG_fail;
   30497           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30498           0 :   if (!SWIG_IsOK(res1)) {
   30499           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_applySLD" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30500             :   }
   30501           0 :   arg1 = (struct layerObj *)(argp1);
   30502           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30503           0 :   if (!SWIG_IsOK(res2)) {
   30504           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_applySLD" "', argument " "2"" of type '" "char *""'");
   30505             :   }
   30506           0 :   arg2 = (char *)(buf2);
   30507           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   30508           0 :   if (!SWIG_IsOK(res3)) {
   30509           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_applySLD" "', argument " "3"" of type '" "char *""'");
   30510             :   }
   30511           0 :   arg3 = (char *)(buf3);
   30512             :   {
   30513           0 :     result = (int)layerObj_applySLD(arg1,arg2,arg3); {
   30514           0 :       errorObj *ms_error = msGetErrorObj();
   30515             :       
   30516           0 :       switch(ms_error->code) {
   30517             :       case MS_NOERR:
   30518             :         break;
   30519           0 :       case MS_NOTFOUND:
   30520           0 :         msResetErrorList();
   30521           0 :         break;
   30522             :       case -1:
   30523             :         break;
   30524           0 :       case MS_IOERR:
   30525           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30526           0 :           _raise_ms_exception();
   30527           0 :           msResetErrorList();
   30528           0 :           return NULL;
   30529             :         }
   30530             :       default:
   30531           0 :         _raise_ms_exception();
   30532           0 :         msResetErrorList();
   30533           0 :         return NULL;
   30534             :       }
   30535             :       
   30536             :     }
   30537             :   }
   30538             :   resultobj = SWIG_From_int((int)(result));
   30539           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30540           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30541             :   return resultobj;
   30542           0 : fail:
   30543           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30544           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30545             :   return NULL;
   30546             : }
   30547             : 
   30548             : 
   30549           0 : SWIGINTERN PyObject *_wrap_layerObj_applySLDURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30550             :   PyObject *resultobj = 0;
   30551             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30552             :   char *arg2 = (char *) 0 ;
   30553             :   char *arg3 = (char *) 0 ;
   30554           0 :   void *argp1 = 0 ;
   30555             :   int res1 = 0 ;
   30556             :   int res2 ;
   30557           0 :   char *buf2 = 0 ;
   30558           0 :   int alloc2 = 0 ;
   30559             :   int res3 ;
   30560           0 :   char *buf3 = 0 ;
   30561           0 :   int alloc3 = 0 ;
   30562           0 :   PyObject * obj0 = 0 ;
   30563           0 :   PyObject * obj1 = 0 ;
   30564           0 :   PyObject * obj2 = 0 ;
   30565             :   int result;
   30566             :   
   30567           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_applySLDURL",&obj0,&obj1,&obj2)) SWIG_fail;
   30568           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30569           0 :   if (!SWIG_IsOK(res1)) {
   30570           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_applySLDURL" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30571             :   }
   30572           0 :   arg1 = (struct layerObj *)(argp1);
   30573           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30574           0 :   if (!SWIG_IsOK(res2)) {
   30575           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_applySLDURL" "', argument " "2"" of type '" "char *""'");
   30576             :   }
   30577           0 :   arg2 = (char *)(buf2);
   30578           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   30579           0 :   if (!SWIG_IsOK(res3)) {
   30580           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_applySLDURL" "', argument " "3"" of type '" "char *""'");
   30581             :   }
   30582           0 :   arg3 = (char *)(buf3);
   30583             :   {
   30584           0 :     result = (int)layerObj_applySLDURL(arg1,arg2,arg3); {
   30585           0 :       errorObj *ms_error = msGetErrorObj();
   30586             :       
   30587           0 :       switch(ms_error->code) {
   30588             :       case MS_NOERR:
   30589             :         break;
   30590           0 :       case MS_NOTFOUND:
   30591           0 :         msResetErrorList();
   30592           0 :         break;
   30593             :       case -1:
   30594             :         break;
   30595           0 :       case MS_IOERR:
   30596           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30597           0 :           _raise_ms_exception();
   30598           0 :           msResetErrorList();
   30599           0 :           return NULL;
   30600             :         }
   30601             :       default:
   30602           0 :         _raise_ms_exception();
   30603           0 :         msResetErrorList();
   30604           0 :         return NULL;
   30605             :       }
   30606             :       
   30607             :     }
   30608             :   }
   30609             :   resultobj = SWIG_From_int((int)(result));
   30610           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30611           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30612             :   return resultobj;
   30613           0 : fail:
   30614           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30615           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30616             :   return NULL;
   30617             : }
   30618             : 
   30619             : 
   30620           0 : SWIGINTERN PyObject *_wrap_layerObj_generateSLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30621             :   PyObject *resultobj = 0;
   30622             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30623           0 :   void *argp1 = 0 ;
   30624             :   int res1 = 0 ;
   30625           0 :   PyObject * obj0 = 0 ;
   30626             :   char *result = 0 ;
   30627             :   
   30628           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_generateSLD",&obj0)) SWIG_fail;
   30629           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30630           0 :   if (!SWIG_IsOK(res1)) {
   30631           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_generateSLD" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30632             :   }
   30633           0 :   arg1 = (struct layerObj *)(argp1);
   30634             :   {
   30635           0 :     result = (char *)layerObj_generateSLD(arg1); {
   30636           0 :       errorObj *ms_error = msGetErrorObj();
   30637             :       
   30638           0 :       switch(ms_error->code) {
   30639             :       case MS_NOERR:
   30640             :         break;
   30641           0 :       case MS_NOTFOUND:
   30642           0 :         msResetErrorList();
   30643           0 :         break;
   30644             :       case -1:
   30645             :         break;
   30646           0 :       case MS_IOERR:
   30647           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30648           0 :           _raise_ms_exception();
   30649           0 :           msResetErrorList();
   30650           0 :           return NULL;
   30651             :         }
   30652             :       default:
   30653           0 :         _raise_ms_exception();
   30654           0 :         msResetErrorList();
   30655           0 :         return NULL;
   30656             :       }
   30657             :       
   30658             :     }
   30659             :   }
   30660           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   30661           0 :   free((char*)result);
   30662           0 :   return resultobj;
   30663           0 : fail:
   30664             :   return NULL;
   30665             : }
   30666             : 
   30667             : 
   30668           1 : SWIGINTERN PyObject *_wrap_layerObj_isVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30669             :   PyObject *resultobj = 0;
   30670             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30671           1 :   void *argp1 = 0 ;
   30672             :   int res1 = 0 ;
   30673           1 :   PyObject * obj0 = 0 ;
   30674             :   int result;
   30675             :   
   30676           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_isVisible",&obj0)) SWIG_fail;
   30677           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30678           1 :   if (!SWIG_IsOK(res1)) {
   30679           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_isVisible" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30680             :   }
   30681           1 :   arg1 = (struct layerObj *)(argp1);
   30682             :   {
   30683           1 :     result = (int)layerObj_isVisible(arg1); {
   30684           1 :       errorObj *ms_error = msGetErrorObj();
   30685             :       
   30686           1 :       switch(ms_error->code) {
   30687             :       case MS_NOERR:
   30688             :         break;
   30689           0 :       case MS_NOTFOUND:
   30690           0 :         msResetErrorList();
   30691           0 :         break;
   30692             :       case -1:
   30693             :         break;
   30694           0 :       case MS_IOERR:
   30695           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30696           0 :           _raise_ms_exception();
   30697           0 :           msResetErrorList();
   30698           0 :           return NULL;
   30699             :         }
   30700             :       default:
   30701           0 :         _raise_ms_exception();
   30702           0 :         msResetErrorList();
   30703           0 :         return NULL;
   30704             :       }
   30705             :       
   30706             :     }
   30707             :   }
   30708             :   resultobj = SWIG_From_int((int)(result));
   30709           1 :   return resultobj;
   30710           0 : fail:
   30711             :   return NULL;
   30712             : }
   30713             : 
   30714             : 
   30715           0 : SWIGINTERN PyObject *_wrap_layerObj_moveClassUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30716             :   PyObject *resultobj = 0;
   30717             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30718             :   int arg2 ;
   30719           0 :   void *argp1 = 0 ;
   30720             :   int res1 = 0 ;
   30721             :   int val2 ;
   30722             :   int ecode2 = 0 ;
   30723           0 :   PyObject * obj0 = 0 ;
   30724           0 :   PyObject * obj1 = 0 ;
   30725             :   int result;
   30726             :   
   30727           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_moveClassUp",&obj0,&obj1)) SWIG_fail;
   30728           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30729           0 :   if (!SWIG_IsOK(res1)) {
   30730           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_moveClassUp" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30731             :   }
   30732           0 :   arg1 = (struct layerObj *)(argp1);
   30733           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   30734           0 :   if (!SWIG_IsOK(ecode2)) {
   30735           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_moveClassUp" "', argument " "2"" of type '" "int""'");
   30736             :   } 
   30737             :   arg2 = (int)(val2);
   30738             :   {
   30739             :     result = (int)layerObj_moveClassUp(arg1,arg2); {
   30740           0 :       errorObj *ms_error = msGetErrorObj();
   30741             :       
   30742           0 :       switch(ms_error->code) {
   30743             :       case MS_NOERR:
   30744             :         break;
   30745           0 :       case MS_NOTFOUND:
   30746           0 :         msResetErrorList();
   30747           0 :         break;
   30748             :       case -1:
   30749             :         break;
   30750           0 :       case MS_IOERR:
   30751           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30752           0 :           _raise_ms_exception();
   30753           0 :           msResetErrorList();
   30754           0 :           return NULL;
   30755             :         }
   30756             :       default:
   30757           0 :         _raise_ms_exception();
   30758           0 :         msResetErrorList();
   30759           0 :         return NULL;
   30760             :       }
   30761             :       
   30762             :     }
   30763             :   }
   30764             :   resultobj = SWIG_From_int((int)(result));
   30765           0 :   return resultobj;
   30766           0 : fail:
   30767             :   return NULL;
   30768             : }
   30769             : 
   30770             : 
   30771           0 : SWIGINTERN PyObject *_wrap_layerObj_moveClassDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30772             :   PyObject *resultobj = 0;
   30773             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30774             :   int arg2 ;
   30775           0 :   void *argp1 = 0 ;
   30776             :   int res1 = 0 ;
   30777             :   int val2 ;
   30778             :   int ecode2 = 0 ;
   30779           0 :   PyObject * obj0 = 0 ;
   30780           0 :   PyObject * obj1 = 0 ;
   30781             :   int result;
   30782             :   
   30783           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_moveClassDown",&obj0,&obj1)) SWIG_fail;
   30784           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30785           0 :   if (!SWIG_IsOK(res1)) {
   30786           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_moveClassDown" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30787             :   }
   30788           0 :   arg1 = (struct layerObj *)(argp1);
   30789           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   30790           0 :   if (!SWIG_IsOK(ecode2)) {
   30791           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_moveClassDown" "', argument " "2"" of type '" "int""'");
   30792             :   } 
   30793             :   arg2 = (int)(val2);
   30794             :   {
   30795             :     result = (int)layerObj_moveClassDown(arg1,arg2); {
   30796           0 :       errorObj *ms_error = msGetErrorObj();
   30797             :       
   30798           0 :       switch(ms_error->code) {
   30799             :       case MS_NOERR:
   30800             :         break;
   30801           0 :       case MS_NOTFOUND:
   30802           0 :         msResetErrorList();
   30803           0 :         break;
   30804             :       case -1:
   30805             :         break;
   30806           0 :       case MS_IOERR:
   30807           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30808           0 :           _raise_ms_exception();
   30809           0 :           msResetErrorList();
   30810           0 :           return NULL;
   30811             :         }
   30812             :       default:
   30813           0 :         _raise_ms_exception();
   30814           0 :         msResetErrorList();
   30815           0 :         return NULL;
   30816             :       }
   30817             :       
   30818             :     }
   30819             :   }
   30820             :   resultobj = SWIG_From_int((int)(result));
   30821           0 :   return resultobj;
   30822           0 : fail:
   30823             :   return NULL;
   30824             : }
   30825             : 
   30826             : 
   30827           0 : SWIGINTERN PyObject *_wrap_layerObj_setProcessingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30828             :   PyObject *resultobj = 0;
   30829             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30830             :   char *arg2 = (char *) 0 ;
   30831             :   char *arg3 = (char *) 0 ;
   30832           0 :   void *argp1 = 0 ;
   30833             :   int res1 = 0 ;
   30834             :   int res2 ;
   30835           0 :   char *buf2 = 0 ;
   30836           0 :   int alloc2 = 0 ;
   30837             :   int res3 ;
   30838           0 :   char *buf3 = 0 ;
   30839           0 :   int alloc3 = 0 ;
   30840           0 :   PyObject * obj0 = 0 ;
   30841           0 :   PyObject * obj1 = 0 ;
   30842           0 :   PyObject * obj2 = 0 ;
   30843             :   
   30844           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setProcessingKey",&obj0,&obj1,&obj2)) SWIG_fail;
   30845           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30846           0 :   if (!SWIG_IsOK(res1)) {
   30847           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setProcessingKey" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30848             :   }
   30849           0 :   arg1 = (struct layerObj *)(argp1);
   30850           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30851           0 :   if (!SWIG_IsOK(res2)) {
   30852           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setProcessingKey" "', argument " "2"" of type '" "char const *""'");
   30853             :   }
   30854           0 :   arg2 = (char *)(buf2);
   30855           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   30856           0 :   if (!SWIG_IsOK(res3)) {
   30857           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_setProcessingKey" "', argument " "3"" of type '" "char const *""'");
   30858             :   }
   30859           0 :   arg3 = (char *)(buf3);
   30860             :   {
   30861             :     layerObj_setProcessingKey(arg1,(char const *)arg2,(char const *)arg3); {
   30862           0 :       errorObj *ms_error = msGetErrorObj();
   30863             :       
   30864           0 :       switch(ms_error->code) {
   30865             :       case MS_NOERR:
   30866             :         break;
   30867           0 :       case MS_NOTFOUND:
   30868           0 :         msResetErrorList();
   30869           0 :         break;
   30870             :       case -1:
   30871             :         break;
   30872           0 :       case MS_IOERR:
   30873           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30874           0 :           _raise_ms_exception();
   30875           0 :           msResetErrorList();
   30876           0 :           return NULL;
   30877             :         }
   30878             :       default:
   30879           0 :         _raise_ms_exception();
   30880           0 :         msResetErrorList();
   30881           0 :         return NULL;
   30882             :       }
   30883             :       
   30884             :     }
   30885             :   }
   30886             :   resultobj = SWIG_Py_Void();
   30887           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30888           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30889             :   return resultobj;
   30890           0 : fail:
   30891           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30892           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   30893             :   return NULL;
   30894             : }
   30895             : 
   30896             : 
   30897           1 : SWIGINTERN PyObject *_wrap_layerObj_setProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30898             :   PyObject *resultobj = 0;
   30899             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30900             :   char *arg2 = (char *) 0 ;
   30901           1 :   void *argp1 = 0 ;
   30902             :   int res1 = 0 ;
   30903             :   int res2 ;
   30904           1 :   char *buf2 = 0 ;
   30905           1 :   int alloc2 = 0 ;
   30906           1 :   PyObject * obj0 = 0 ;
   30907           1 :   PyObject * obj1 = 0 ;
   30908             :   
   30909           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setProcessing",&obj0,&obj1)) SWIG_fail;
   30910           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30911           1 :   if (!SWIG_IsOK(res1)) {
   30912           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setProcessing" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30913             :   }
   30914           1 :   arg1 = (struct layerObj *)(argp1);
   30915           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30916           1 :   if (!SWIG_IsOK(res2)) {
   30917           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setProcessing" "', argument " "2"" of type '" "char const *""'");
   30918             :   }
   30919           1 :   arg2 = (char *)(buf2);
   30920             :   {
   30921             :     layerObj_setProcessing(arg1,(char const *)arg2); {
   30922           1 :       errorObj *ms_error = msGetErrorObj();
   30923             :       
   30924           1 :       switch(ms_error->code) {
   30925             :       case MS_NOERR:
   30926             :         break;
   30927           0 :       case MS_NOTFOUND:
   30928           0 :         msResetErrorList();
   30929           0 :         break;
   30930             :       case -1:
   30931             :         break;
   30932           0 :       case MS_IOERR:
   30933           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30934           0 :           _raise_ms_exception();
   30935           0 :           msResetErrorList();
   30936           0 :           return NULL;
   30937             :         }
   30938             :       default:
   30939           0 :         _raise_ms_exception();
   30940           0 :         msResetErrorList();
   30941           0 :         return NULL;
   30942             :       }
   30943             :       
   30944             :     }
   30945             :   }
   30946             :   resultobj = SWIG_Py_Void();
   30947           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30948             :   return resultobj;
   30949           0 : fail:
   30950           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   30951             :   return NULL;
   30952             : }
   30953             : 
   30954             : 
   30955           0 : SWIGINTERN PyObject *_wrap_layerObj_addProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   30956             :   PyObject *resultobj = 0;
   30957             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   30958             :   char *arg2 = (char *) 0 ;
   30959           0 :   void *argp1 = 0 ;
   30960             :   int res1 = 0 ;
   30961             :   int res2 ;
   30962           0 :   char *buf2 = 0 ;
   30963           0 :   int alloc2 = 0 ;
   30964           0 :   PyObject * obj0 = 0 ;
   30965           0 :   PyObject * obj1 = 0 ;
   30966             :   
   30967           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_addProcessing",&obj0,&obj1)) SWIG_fail;
   30968           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   30969           0 :   if (!SWIG_IsOK(res1)) {
   30970           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_addProcessing" "', argument " "1"" of type '" "struct layerObj *""'"); 
   30971             :   }
   30972           0 :   arg1 = (struct layerObj *)(argp1);
   30973           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   30974           0 :   if (!SWIG_IsOK(res2)) {
   30975           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_addProcessing" "', argument " "2"" of type '" "char const *""'");
   30976             :   }
   30977           0 :   arg2 = (char *)(buf2);
   30978             :   {
   30979             :     layerObj_addProcessing(arg1,(char const *)arg2); {
   30980           0 :       errorObj *ms_error = msGetErrorObj();
   30981             :       
   30982           0 :       switch(ms_error->code) {
   30983             :       case MS_NOERR:
   30984             :         break;
   30985           0 :       case MS_NOTFOUND:
   30986           0 :         msResetErrorList();
   30987           0 :         break;
   30988             :       case -1:
   30989             :         break;
   30990           0 :       case MS_IOERR:
   30991           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   30992           0 :           _raise_ms_exception();
   30993           0 :           msResetErrorList();
   30994           0 :           return NULL;
   30995             :         }
   30996             :       default:
   30997           0 :         _raise_ms_exception();
   30998           0 :         msResetErrorList();
   30999           0 :         return NULL;
   31000             :       }
   31001             :       
   31002             :     }
   31003             :   }
   31004             :   resultobj = SWIG_Py_Void();
   31005           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31006             :   return resultobj;
   31007           0 : fail:
   31008           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31009             :   return NULL;
   31010             : }
   31011             : 
   31012             : 
   31013           1 : SWIGINTERN PyObject *_wrap_layerObj_getProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31014             :   PyObject *resultobj = 0;
   31015             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31016             :   int arg2 ;
   31017           1 :   void *argp1 = 0 ;
   31018             :   int res1 = 0 ;
   31019             :   int val2 ;
   31020             :   int ecode2 = 0 ;
   31021           1 :   PyObject * obj0 = 0 ;
   31022           1 :   PyObject * obj1 = 0 ;
   31023             :   char *result = 0 ;
   31024             :   
   31025           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getProcessing",&obj0,&obj1)) SWIG_fail;
   31026           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31027           1 :   if (!SWIG_IsOK(res1)) {
   31028           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getProcessing" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31029             :   }
   31030           1 :   arg1 = (struct layerObj *)(argp1);
   31031           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31032           1 :   if (!SWIG_IsOK(ecode2)) {
   31033           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getProcessing" "', argument " "2"" of type '" "int""'");
   31034             :   } 
   31035             :   arg2 = (int)(val2);
   31036             :   {
   31037             :     result = (char *)layerObj_getProcessing(arg1,arg2); {
   31038           1 :       errorObj *ms_error = msGetErrorObj();
   31039             :       
   31040           1 :       switch(ms_error->code) {
   31041             :       case MS_NOERR:
   31042             :         break;
   31043           0 :       case MS_NOTFOUND:
   31044           0 :         msResetErrorList();
   31045           0 :         break;
   31046             :       case -1:
   31047             :         break;
   31048           0 :       case MS_IOERR:
   31049           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31050           0 :           _raise_ms_exception();
   31051           0 :           msResetErrorList();
   31052           0 :           return NULL;
   31053             :         }
   31054             :       default:
   31055           0 :         _raise_ms_exception();
   31056           0 :         msResetErrorList();
   31057           0 :         return NULL;
   31058             :       }
   31059             :       
   31060             :     }
   31061             :   }
   31062           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   31063           1 :   return resultobj;
   31064           0 : fail:
   31065             :   return NULL;
   31066             : }
   31067             : 
   31068             : 
   31069           0 : SWIGINTERN PyObject *_wrap_layerObj_getProcessingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31070             :   PyObject *resultobj = 0;
   31071             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31072             :   char *arg2 = (char *) 0 ;
   31073           0 :   void *argp1 = 0 ;
   31074             :   int res1 = 0 ;
   31075             :   int res2 ;
   31076           0 :   char *buf2 = 0 ;
   31077           0 :   int alloc2 = 0 ;
   31078           0 :   PyObject * obj0 = 0 ;
   31079           0 :   PyObject * obj1 = 0 ;
   31080             :   char *result = 0 ;
   31081             :   
   31082           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getProcessingKey",&obj0,&obj1)) SWIG_fail;
   31083           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31084           0 :   if (!SWIG_IsOK(res1)) {
   31085           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getProcessingKey" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31086             :   }
   31087           0 :   arg1 = (struct layerObj *)(argp1);
   31088           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   31089           0 :   if (!SWIG_IsOK(res2)) {
   31090           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getProcessingKey" "', argument " "2"" of type '" "char const *""'");
   31091             :   }
   31092           0 :   arg2 = (char *)(buf2);
   31093             :   {
   31094             :     result = (char *)layerObj_getProcessingKey(arg1,(char const *)arg2); {
   31095           0 :       errorObj *ms_error = msGetErrorObj();
   31096             :       
   31097           0 :       switch(ms_error->code) {
   31098             :       case MS_NOERR:
   31099             :         break;
   31100           0 :       case MS_NOTFOUND:
   31101           0 :         msResetErrorList();
   31102           0 :         break;
   31103             :       case -1:
   31104             :         break;
   31105           0 :       case MS_IOERR:
   31106           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31107           0 :           _raise_ms_exception();
   31108           0 :           msResetErrorList();
   31109           0 :           return NULL;
   31110             :         }
   31111             :       default:
   31112           0 :         _raise_ms_exception();
   31113           0 :         msResetErrorList();
   31114           0 :         return NULL;
   31115             :       }
   31116             :       
   31117             :     }
   31118             :   }
   31119           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   31120           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31121             :   return resultobj;
   31122           0 : fail:
   31123           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31124             :   return NULL;
   31125             : }
   31126             : 
   31127             : 
   31128           1 : SWIGINTERN PyObject *_wrap_layerObj_clearProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31129             :   PyObject *resultobj = 0;
   31130             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31131           1 :   void *argp1 = 0 ;
   31132             :   int res1 = 0 ;
   31133           1 :   PyObject * obj0 = 0 ;
   31134             :   int result;
   31135             :   
   31136           1 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_clearProcessing",&obj0)) SWIG_fail;
   31137           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31138           1 :   if (!SWIG_IsOK(res1)) {
   31139           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_clearProcessing" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31140             :   }
   31141           1 :   arg1 = (struct layerObj *)(argp1);
   31142             :   {
   31143             :     result = (int)layerObj_clearProcessing(arg1); {
   31144           1 :       errorObj *ms_error = msGetErrorObj();
   31145             :       
   31146           1 :       switch(ms_error->code) {
   31147             :       case MS_NOERR:
   31148             :         break;
   31149           0 :       case MS_NOTFOUND:
   31150           0 :         msResetErrorList();
   31151           0 :         break;
   31152             :       case -1:
   31153             :         break;
   31154           0 :       case MS_IOERR:
   31155           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31156           0 :           _raise_ms_exception();
   31157           0 :           msResetErrorList();
   31158           0 :           return NULL;
   31159             :         }
   31160             :       default:
   31161           0 :         _raise_ms_exception();
   31162           0 :         msResetErrorList();
   31163           0 :         return NULL;
   31164             :       }
   31165             :       
   31166             :     }
   31167             :   }
   31168             :   resultobj = SWIG_From_int((int)(result));
   31169           1 :   return resultobj;
   31170           0 : fail:
   31171             :   return NULL;
   31172             : }
   31173             : 
   31174             : 
   31175           0 : SWIGINTERN PyObject *_wrap_layerObj_setConnectionType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31176             :   PyObject *resultobj = 0;
   31177             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31178             :   int arg2 ;
   31179             :   char *arg3 = (char *) 0 ;
   31180           0 :   void *argp1 = 0 ;
   31181             :   int res1 = 0 ;
   31182             :   int val2 ;
   31183             :   int ecode2 = 0 ;
   31184             :   int res3 ;
   31185           0 :   char *buf3 = 0 ;
   31186           0 :   int alloc3 = 0 ;
   31187           0 :   PyObject * obj0 = 0 ;
   31188           0 :   PyObject * obj1 = 0 ;
   31189           0 :   PyObject * obj2 = 0 ;
   31190             :   int result;
   31191             :   
   31192           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setConnectionType",&obj0,&obj1,&obj2)) SWIG_fail;
   31193           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31194           0 :   if (!SWIG_IsOK(res1)) {
   31195           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setConnectionType" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31196             :   }
   31197           0 :   arg1 = (struct layerObj *)(argp1);
   31198           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31199           0 :   if (!SWIG_IsOK(ecode2)) {
   31200           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_setConnectionType" "', argument " "2"" of type '" "int""'");
   31201             :   } 
   31202             :   arg2 = (int)(val2);
   31203           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   31204           0 :   if (!SWIG_IsOK(res3)) {
   31205           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_setConnectionType" "', argument " "3"" of type '" "char const *""'");
   31206             :   }
   31207           0 :   arg3 = (char *)(buf3);
   31208             :   {
   31209           0 :     result = (int)layerObj_setConnectionType(arg1,arg2,(char const *)arg3); {
   31210           0 :       errorObj *ms_error = msGetErrorObj();
   31211             :       
   31212           0 :       switch(ms_error->code) {
   31213             :       case MS_NOERR:
   31214             :         break;
   31215           0 :       case MS_NOTFOUND:
   31216           0 :         msResetErrorList();
   31217           0 :         break;
   31218             :       case -1:
   31219             :         break;
   31220           0 :       case MS_IOERR:
   31221           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31222           0 :           _raise_ms_exception();
   31223           0 :           msResetErrorList();
   31224           0 :           return NULL;
   31225             :         }
   31226             :       default:
   31227           0 :         _raise_ms_exception();
   31228           0 :         msResetErrorList();
   31229           0 :         return NULL;
   31230             :       }
   31231             :       
   31232             :     }
   31233             :   }
   31234             :   resultobj = SWIG_From_int((int)(result));
   31235           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   31236             :   return resultobj;
   31237           0 : fail:
   31238           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   31239             :   return NULL;
   31240             : }
   31241             : 
   31242             : 
   31243           0 : SWIGINTERN PyObject *_wrap_layerObj_getClassIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31244             :   PyObject *resultobj = 0;
   31245             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31246             :   mapObj *arg2 = (mapObj *) 0 ;
   31247             :   shapeObj *arg3 = (shapeObj *) 0 ;
   31248             :   int *arg4 = (int *) NULL ;
   31249             :   int arg5 = (int) 0 ;
   31250           0 :   void *argp1 = 0 ;
   31251             :   int res1 = 0 ;
   31252           0 :   void *argp2 = 0 ;
   31253             :   int res2 = 0 ;
   31254           0 :   void *argp3 = 0 ;
   31255             :   int res3 = 0 ;
   31256           0 :   void *argp4 = 0 ;
   31257             :   int res4 = 0 ;
   31258             :   int val5 ;
   31259             :   int ecode5 = 0 ;
   31260           0 :   PyObject * obj0 = 0 ;
   31261           0 :   PyObject * obj1 = 0 ;
   31262           0 :   PyObject * obj2 = 0 ;
   31263           0 :   PyObject * obj3 = 0 ;
   31264           0 :   PyObject * obj4 = 0 ;
   31265             :   int result;
   31266             :   
   31267           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO|OO:layerObj_getClassIndex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   31268           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31269           0 :   if (!SWIG_IsOK(res1)) {
   31270           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getClassIndex" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31271             :   }
   31272           0 :   arg1 = (struct layerObj *)(argp1);
   31273           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   31274           0 :   if (!SWIG_IsOK(res2)) {
   31275           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getClassIndex" "', argument " "2"" of type '" "mapObj *""'"); 
   31276             :   }
   31277           0 :   arg2 = (mapObj *)(argp2);
   31278           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_shapeObj, 0 |  0 );
   31279           0 :   if (!SWIG_IsOK(res3)) {
   31280           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_getClassIndex" "', argument " "3"" of type '" "shapeObj *""'"); 
   31281             :   }
   31282           0 :   arg3 = (shapeObj *)(argp3);
   31283           0 :   if (obj3) {
   31284           0 :     res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
   31285           0 :     if (!SWIG_IsOK(res4)) {
   31286           0 :       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "layerObj_getClassIndex" "', argument " "4"" of type '" "int *""'"); 
   31287             :     }
   31288           0 :     arg4 = (int *)(argp4);
   31289             :   }
   31290           0 :   if (obj4) {
   31291             :     ecode5 = SWIG_AsVal_int(obj4, &val5);
   31292           0 :     if (!SWIG_IsOK(ecode5)) {
   31293           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_getClassIndex" "', argument " "5"" of type '" "int""'");
   31294             :     } 
   31295             :     arg5 = (int)(val5);
   31296             :   }
   31297             :   {
   31298             :     result = (int)layerObj_getClassIndex(arg1,arg2,arg3,arg4,arg5); {
   31299           0 :       errorObj *ms_error = msGetErrorObj();
   31300             :       
   31301           0 :       switch(ms_error->code) {
   31302             :       case MS_NOERR:
   31303             :         break;
   31304           0 :       case MS_NOTFOUND:
   31305           0 :         msResetErrorList();
   31306           0 :         break;
   31307             :       case -1:
   31308             :         break;
   31309           0 :       case MS_IOERR:
   31310           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31311           0 :           _raise_ms_exception();
   31312           0 :           msResetErrorList();
   31313           0 :           return NULL;
   31314             :         }
   31315             :       default:
   31316           0 :         _raise_ms_exception();
   31317           0 :         msResetErrorList();
   31318           0 :         return NULL;
   31319             :       }
   31320             :       
   31321             :     }
   31322             :   }
   31323             :   resultobj = SWIG_From_int((int)(result));
   31324           0 :   return resultobj;
   31325           0 : fail:
   31326             :   return NULL;
   31327             : }
   31328             : 
   31329             : 
   31330           0 : SWIGINTERN PyObject *_wrap_layerObj_getGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31331             :   PyObject *resultobj = 0;
   31332             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31333           0 :   void *argp1 = 0 ;
   31334             :   int res1 = 0 ;
   31335           0 :   PyObject * obj0 = 0 ;
   31336             :   char *result = 0 ;
   31337             :   
   31338           0 :   if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getGeomTransform",&obj0)) SWIG_fail;
   31339           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31340           0 :   if (!SWIG_IsOK(res1)) {
   31341           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getGeomTransform" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31342             :   }
   31343           0 :   arg1 = (struct layerObj *)(argp1);
   31344             :   {
   31345           0 :     result = (char *)layerObj_getGeomTransform(arg1); {
   31346           0 :       errorObj *ms_error = msGetErrorObj();
   31347             :       
   31348           0 :       switch(ms_error->code) {
   31349             :       case MS_NOERR:
   31350             :         break;
   31351           0 :       case MS_NOTFOUND:
   31352           0 :         msResetErrorList();
   31353           0 :         break;
   31354             :       case -1:
   31355             :         break;
   31356           0 :       case MS_IOERR:
   31357           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31358           0 :           _raise_ms_exception();
   31359           0 :           msResetErrorList();
   31360           0 :           return NULL;
   31361             :         }
   31362             :       default:
   31363           0 :         _raise_ms_exception();
   31364           0 :         msResetErrorList();
   31365           0 :         return NULL;
   31366             :       }
   31367             :       
   31368             :     }
   31369             :   }
   31370           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   31371           0 :   return resultobj;
   31372           0 : fail:
   31373             :   return NULL;
   31374             : }
   31375             : 
   31376             : 
   31377           0 : SWIGINTERN PyObject *_wrap_layerObj_setGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31378             :   PyObject *resultobj = 0;
   31379             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31380             :   char *arg2 = (char *) 0 ;
   31381           0 :   void *argp1 = 0 ;
   31382             :   int res1 = 0 ;
   31383             :   int res2 ;
   31384           0 :   char *buf2 = 0 ;
   31385           0 :   int alloc2 = 0 ;
   31386           0 :   PyObject * obj0 = 0 ;
   31387           0 :   PyObject * obj1 = 0 ;
   31388             :   
   31389           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setGeomTransform",&obj0,&obj1)) SWIG_fail;
   31390           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31391           0 :   if (!SWIG_IsOK(res1)) {
   31392           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setGeomTransform" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31393             :   }
   31394           0 :   arg1 = (struct layerObj *)(argp1);
   31395           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   31396           0 :   if (!SWIG_IsOK(res2)) {
   31397           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setGeomTransform" "', argument " "2"" of type '" "char *""'");
   31398             :   }
   31399           0 :   arg2 = (char *)(buf2);
   31400             :   {
   31401           0 :     layerObj_setGeomTransform(arg1,arg2); {
   31402           0 :       errorObj *ms_error = msGetErrorObj();
   31403             :       
   31404           0 :       switch(ms_error->code) {
   31405             :       case MS_NOERR:
   31406             :         break;
   31407           0 :       case MS_NOTFOUND:
   31408           0 :         msResetErrorList();
   31409           0 :         break;
   31410             :       case -1:
   31411             :         break;
   31412           0 :       case MS_IOERR:
   31413           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31414           0 :           _raise_ms_exception();
   31415           0 :           msResetErrorList();
   31416           0 :           return NULL;
   31417             :         }
   31418             :       default:
   31419           0 :         _raise_ms_exception();
   31420           0 :         msResetErrorList();
   31421           0 :         return NULL;
   31422             :       }
   31423             :       
   31424             :     }
   31425             :   }
   31426             :   resultobj = SWIG_Py_Void();
   31427           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31428             :   return resultobj;
   31429           0 : fail:
   31430           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31431             :   return NULL;
   31432             : }
   31433             : 
   31434             : 
   31435           1 : SWIGINTERN PyObject *_wrap_layerObj_getItemType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31436             :   PyObject *resultobj = 0;
   31437             :   struct layerObj *arg1 = (struct layerObj *) 0 ;
   31438             :   int arg2 ;
   31439           1 :   void *argp1 = 0 ;
   31440             :   int res1 = 0 ;
   31441             :   int val2 ;
   31442             :   int ecode2 = 0 ;
   31443           1 :   PyObject * obj0 = 0 ;
   31444           1 :   PyObject * obj1 = 0 ;
   31445             :   char *result = 0 ;
   31446             :   
   31447           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getItemType",&obj0,&obj1)) SWIG_fail;
   31448           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 |  0 );
   31449           1 :   if (!SWIG_IsOK(res1)) {
   31450           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getItemType" "', argument " "1"" of type '" "struct layerObj *""'"); 
   31451             :   }
   31452           1 :   arg1 = (struct layerObj *)(argp1);
   31453           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31454           1 :   if (!SWIG_IsOK(ecode2)) {
   31455           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getItemType" "', argument " "2"" of type '" "int""'");
   31456             :   } 
   31457             :   arg2 = (int)(val2);
   31458             :   {
   31459           1 :     result = (char *)layerObj_getItemType(arg1,arg2); {
   31460           1 :       errorObj *ms_error = msGetErrorObj();
   31461             :       
   31462           1 :       switch(ms_error->code) {
   31463             :       case MS_NOERR:
   31464             :         break;
   31465           0 :       case MS_NOTFOUND:
   31466           0 :         msResetErrorList();
   31467           0 :         break;
   31468             :       case -1:
   31469             :         break;
   31470           0 :       case MS_IOERR:
   31471           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   31472           0 :           _raise_ms_exception();
   31473           0 :           msResetErrorList();
   31474           0 :           return NULL;
   31475             :         }
   31476             :       default:
   31477           0 :         _raise_ms_exception();
   31478           0 :         msResetErrorList();
   31479           0 :         return NULL;
   31480             :       }
   31481             :       
   31482             :     }
   31483             :   }
   31484           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   31485           1 :   return resultobj;
   31486           0 : fail:
   31487             :   return NULL;
   31488             : }
   31489             : 
   31490             : 
   31491           1 : SWIGINTERN PyObject *layerObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31492             :   PyObject *obj;
   31493           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   31494           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_layerObj, SWIG_NewClientData(obj));
   31495           1 :   return SWIG_Py_Void();
   31496             : }
   31497             : 
   31498           0 : SWIGINTERN PyObject *_wrap_mapObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31499             :   PyObject *resultobj = 0;
   31500             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31501             :   char *arg2 = (char *) 0 ;
   31502           0 :   void *argp1 = 0 ;
   31503             :   int res1 = 0 ;
   31504             :   int res2 ;
   31505           0 :   char *buf2 = 0 ;
   31506           0 :   int alloc2 = 0 ;
   31507           0 :   PyObject * obj0 = 0 ;
   31508           0 :   PyObject * obj1 = 0 ;
   31509             :   
   31510           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_name_set",&obj0,&obj1)) SWIG_fail;
   31511           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31512           0 :   if (!SWIG_IsOK(res1)) {
   31513           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_name_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31514             :   }
   31515           0 :   arg1 = (struct mapObj *)(argp1);
   31516           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   31517           0 :   if (!SWIG_IsOK(res2)) {
   31518           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_name_set" "', argument " "2"" of type '" "char *""'");
   31519             :   }
   31520           0 :   arg2 = (char *)(buf2);
   31521             :   {
   31522           0 :     if (arg1->name) free((char*)arg1->name);
   31523           0 :     if (arg2) {
   31524           0 :       arg1->name = (char *) malloc(strlen(arg2)+1);
   31525             :       strcpy((char*)arg1->name,arg2);
   31526             :     } else {
   31527           0 :       arg1->name = 0;
   31528             :     }
   31529             :   }
   31530             :   resultobj = SWIG_Py_Void();
   31531           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31532             :   return resultobj;
   31533           0 : fail:
   31534           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   31535             :   return NULL;
   31536             : }
   31537             : 
   31538             : 
   31539           1 : SWIGINTERN PyObject *_wrap_mapObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31540             :   PyObject *resultobj = 0;
   31541             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31542           1 :   void *argp1 = 0 ;
   31543             :   int res1 = 0 ;
   31544           1 :   PyObject * obj0 = 0 ;
   31545             :   char *result = 0 ;
   31546             :   
   31547           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_name_get",&obj0)) SWIG_fail;
   31548           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31549           1 :   if (!SWIG_IsOK(res1)) {
   31550           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_name_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31551             :   }
   31552           1 :   arg1 = (struct mapObj *)(argp1);
   31553           1 :   result = (char *) ((arg1)->name);
   31554           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   31555           1 :   return resultobj;
   31556           0 : fail:
   31557             :   return NULL;
   31558             : }
   31559             : 
   31560             : 
   31561           0 : SWIGINTERN PyObject *_wrap_mapObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31562             :   PyObject *resultobj = 0;
   31563             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31564             :   int arg2 ;
   31565           0 :   void *argp1 = 0 ;
   31566             :   int res1 = 0 ;
   31567             :   int val2 ;
   31568             :   int ecode2 = 0 ;
   31569           0 :   PyObject * obj0 = 0 ;
   31570           0 :   PyObject * obj1 = 0 ;
   31571             :   
   31572           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_status_set",&obj0,&obj1)) SWIG_fail;
   31573           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31574           0 :   if (!SWIG_IsOK(res1)) {
   31575           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_status_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31576             :   }
   31577           0 :   arg1 = (struct mapObj *)(argp1);
   31578           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31579           0 :   if (!SWIG_IsOK(ecode2)) {
   31580           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_status_set" "', argument " "2"" of type '" "int""'");
   31581             :   } 
   31582             :   arg2 = (int)(val2);
   31583           0 :   if (arg1) (arg1)->status = arg2;
   31584             :   resultobj = SWIG_Py_Void();
   31585           0 :   return resultobj;
   31586           0 : fail:
   31587             :   return NULL;
   31588             : }
   31589             : 
   31590             : 
   31591           0 : SWIGINTERN PyObject *_wrap_mapObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31592             :   PyObject *resultobj = 0;
   31593             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31594           0 :   void *argp1 = 0 ;
   31595             :   int res1 = 0 ;
   31596           0 :   PyObject * obj0 = 0 ;
   31597             :   int result;
   31598             :   
   31599           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_status_get",&obj0)) SWIG_fail;
   31600           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31601           0 :   if (!SWIG_IsOK(res1)) {
   31602           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_status_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31603             :   }
   31604           0 :   arg1 = (struct mapObj *)(argp1);
   31605           0 :   result = (int) ((arg1)->status);
   31606             :   resultobj = SWIG_From_int((int)(result));
   31607           0 :   return resultobj;
   31608           0 : fail:
   31609             :   return NULL;
   31610             : }
   31611             : 
   31612             : 
   31613           1 : SWIGINTERN PyObject *_wrap_mapObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31614             :   PyObject *resultobj = 0;
   31615             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31616             :   int arg2 ;
   31617           1 :   void *argp1 = 0 ;
   31618             :   int res1 = 0 ;
   31619             :   int val2 ;
   31620             :   int ecode2 = 0 ;
   31621           1 :   PyObject * obj0 = 0 ;
   31622           1 :   PyObject * obj1 = 0 ;
   31623             :   
   31624           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_height_set",&obj0,&obj1)) SWIG_fail;
   31625           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31626           1 :   if (!SWIG_IsOK(res1)) {
   31627           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_height_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31628             :   }
   31629           1 :   arg1 = (struct mapObj *)(argp1);
   31630           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31631           1 :   if (!SWIG_IsOK(ecode2)) {
   31632           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_height_set" "', argument " "2"" of type '" "int""'");
   31633             :   } 
   31634             :   arg2 = (int)(val2);
   31635           1 :   if (arg1) (arg1)->height = arg2;
   31636             :   resultobj = SWIG_Py_Void();
   31637           1 :   return resultobj;
   31638           0 : fail:
   31639             :   return NULL;
   31640             : }
   31641             : 
   31642             : 
   31643           0 : SWIGINTERN PyObject *_wrap_mapObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31644             :   PyObject *resultobj = 0;
   31645             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31646           0 :   void *argp1 = 0 ;
   31647             :   int res1 = 0 ;
   31648           0 :   PyObject * obj0 = 0 ;
   31649             :   int result;
   31650             :   
   31651           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_height_get",&obj0)) SWIG_fail;
   31652           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31653           0 :   if (!SWIG_IsOK(res1)) {
   31654           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_height_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31655             :   }
   31656           0 :   arg1 = (struct mapObj *)(argp1);
   31657           0 :   result = (int) ((arg1)->height);
   31658             :   resultobj = SWIG_From_int((int)(result));
   31659           0 :   return resultobj;
   31660           0 : fail:
   31661             :   return NULL;
   31662             : }
   31663             : 
   31664             : 
   31665           1 : SWIGINTERN PyObject *_wrap_mapObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31666             :   PyObject *resultobj = 0;
   31667             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31668             :   int arg2 ;
   31669           1 :   void *argp1 = 0 ;
   31670             :   int res1 = 0 ;
   31671             :   int val2 ;
   31672             :   int ecode2 = 0 ;
   31673           1 :   PyObject * obj0 = 0 ;
   31674           1 :   PyObject * obj1 = 0 ;
   31675             :   
   31676           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_width_set",&obj0,&obj1)) SWIG_fail;
   31677           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31678           1 :   if (!SWIG_IsOK(res1)) {
   31679           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_width_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31680             :   }
   31681           1 :   arg1 = (struct mapObj *)(argp1);
   31682           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31683           1 :   if (!SWIG_IsOK(ecode2)) {
   31684           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_width_set" "', argument " "2"" of type '" "int""'");
   31685             :   } 
   31686             :   arg2 = (int)(val2);
   31687           1 :   if (arg1) (arg1)->width = arg2;
   31688             :   resultobj = SWIG_Py_Void();
   31689           1 :   return resultobj;
   31690           0 : fail:
   31691             :   return NULL;
   31692             : }
   31693             : 
   31694             : 
   31695           0 : SWIGINTERN PyObject *_wrap_mapObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31696             :   PyObject *resultobj = 0;
   31697             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31698           0 :   void *argp1 = 0 ;
   31699             :   int res1 = 0 ;
   31700           0 :   PyObject * obj0 = 0 ;
   31701             :   int result;
   31702             :   
   31703           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_width_get",&obj0)) SWIG_fail;
   31704           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31705           0 :   if (!SWIG_IsOK(res1)) {
   31706           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_width_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31707             :   }
   31708           0 :   arg1 = (struct mapObj *)(argp1);
   31709           0 :   result = (int) ((arg1)->width);
   31710             :   resultobj = SWIG_From_int((int)(result));
   31711           0 :   return resultobj;
   31712           0 : fail:
   31713             :   return NULL;
   31714             : }
   31715             : 
   31716             : 
   31717           0 : SWIGINTERN PyObject *_wrap_mapObj_maxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31718             :   PyObject *resultobj = 0;
   31719             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31720             :   int arg2 ;
   31721           0 :   void *argp1 = 0 ;
   31722             :   int res1 = 0 ;
   31723             :   int val2 ;
   31724             :   int ecode2 = 0 ;
   31725           0 :   PyObject * obj0 = 0 ;
   31726           0 :   PyObject * obj1 = 0 ;
   31727             :   
   31728           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_maxsize_set",&obj0,&obj1)) SWIG_fail;
   31729           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31730           0 :   if (!SWIG_IsOK(res1)) {
   31731           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_maxsize_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31732             :   }
   31733           0 :   arg1 = (struct mapObj *)(argp1);
   31734           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31735           0 :   if (!SWIG_IsOK(ecode2)) {
   31736           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_maxsize_set" "', argument " "2"" of type '" "int""'");
   31737             :   } 
   31738             :   arg2 = (int)(val2);
   31739           0 :   if (arg1) (arg1)->maxsize = arg2;
   31740             :   resultobj = SWIG_Py_Void();
   31741           0 :   return resultobj;
   31742           0 : fail:
   31743             :   return NULL;
   31744             : }
   31745             : 
   31746             : 
   31747           0 : SWIGINTERN PyObject *_wrap_mapObj_maxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31748             :   PyObject *resultobj = 0;
   31749             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31750           0 :   void *argp1 = 0 ;
   31751             :   int res1 = 0 ;
   31752           0 :   PyObject * obj0 = 0 ;
   31753             :   int result;
   31754             :   
   31755           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_maxsize_get",&obj0)) SWIG_fail;
   31756           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31757           0 :   if (!SWIG_IsOK(res1)) {
   31758           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_maxsize_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31759             :   }
   31760           0 :   arg1 = (struct mapObj *)(argp1);
   31761           0 :   result = (int) ((arg1)->maxsize);
   31762             :   resultobj = SWIG_From_int((int)(result));
   31763           0 :   return resultobj;
   31764           0 : fail:
   31765             :   return NULL;
   31766             : }
   31767             : 
   31768             : 
   31769           1 : SWIGINTERN PyObject *_wrap_mapObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31770             :   PyObject *resultobj = 0;
   31771             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31772           1 :   void *argp1 = 0 ;
   31773             :   int res1 = 0 ;
   31774           1 :   PyObject * obj0 = 0 ;
   31775             :   int result;
   31776             :   
   31777           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_refcount_get",&obj0)) SWIG_fail;
   31778           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31779           1 :   if (!SWIG_IsOK(res1)) {
   31780           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_refcount_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31781             :   }
   31782           1 :   arg1 = (struct mapObj *)(argp1);
   31783           1 :   result = (int) ((arg1)->refcount);
   31784             :   resultobj = SWIG_From_int((int)(result));
   31785           1 :   return resultobj;
   31786           0 : fail:
   31787             :   return NULL;
   31788             : }
   31789             : 
   31790             : 
   31791           1 : SWIGINTERN PyObject *_wrap_mapObj_numlayers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31792             :   PyObject *resultobj = 0;
   31793             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31794           1 :   void *argp1 = 0 ;
   31795             :   int res1 = 0 ;
   31796           1 :   PyObject * obj0 = 0 ;
   31797             :   int result;
   31798             :   
   31799           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_numlayers_get",&obj0)) SWIG_fail;
   31800           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31801           1 :   if (!SWIG_IsOK(res1)) {
   31802           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_numlayers_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31803             :   }
   31804           1 :   arg1 = (struct mapObj *)(argp1);
   31805           1 :   result = (int) ((arg1)->numlayers);
   31806             :   resultobj = SWIG_From_int((int)(result));
   31807           1 :   return resultobj;
   31808           0 : fail:
   31809             :   return NULL;
   31810             : }
   31811             : 
   31812             : 
   31813           0 : SWIGINTERN PyObject *_wrap_mapObj_maxlayers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31814             :   PyObject *resultobj = 0;
   31815             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31816           0 :   void *argp1 = 0 ;
   31817             :   int res1 = 0 ;
   31818           0 :   PyObject * obj0 = 0 ;
   31819             :   int result;
   31820             :   
   31821           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_maxlayers_get",&obj0)) SWIG_fail;
   31822           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31823           0 :   if (!SWIG_IsOK(res1)) {
   31824           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_maxlayers_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31825             :   }
   31826           0 :   arg1 = (struct mapObj *)(argp1);
   31827           0 :   result = (int) ((arg1)->maxlayers);
   31828             :   resultobj = SWIG_From_int((int)(result));
   31829           0 :   return resultobj;
   31830           0 : fail:
   31831             :   return NULL;
   31832             : }
   31833             : 
   31834             : 
   31835           1 : SWIGINTERN PyObject *_wrap_mapObj_symbolset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31836             :   PyObject *resultobj = 0;
   31837             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31838           1 :   void *argp1 = 0 ;
   31839             :   int res1 = 0 ;
   31840           1 :   PyObject * obj0 = 0 ;
   31841             :   symbolSetObj *result = 0 ;
   31842             :   
   31843           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_symbolset_get",&obj0)) SWIG_fail;
   31844           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31845           1 :   if (!SWIG_IsOK(res1)) {
   31846           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_symbolset_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31847             :   }
   31848           1 :   arg1 = (struct mapObj *)(argp1);
   31849           1 :   result = (symbolSetObj *)& ((arg1)->symbolset);
   31850           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolSetObj, 0 |  0 );
   31851           1 :   return resultobj;
   31852           0 : fail:
   31853             :   return NULL;
   31854             : }
   31855             : 
   31856             : 
   31857           1 : SWIGINTERN PyObject *_wrap_mapObj_fontset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31858             :   PyObject *resultobj = 0;
   31859             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31860           1 :   void *argp1 = 0 ;
   31861             :   int res1 = 0 ;
   31862           1 :   PyObject * obj0 = 0 ;
   31863             :   fontSetObj *result = 0 ;
   31864             :   
   31865           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_fontset_get",&obj0)) SWIG_fail;
   31866           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31867           1 :   if (!SWIG_IsOK(res1)) {
   31868           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_fontset_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31869             :   }
   31870           1 :   arg1 = (struct mapObj *)(argp1);
   31871           1 :   result = (fontSetObj *)& ((arg1)->fontset);
   31872           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fontSetObj, 0 |  0 );
   31873           1 :   return resultobj;
   31874           0 : fail:
   31875             :   return NULL;
   31876             : }
   31877             : 
   31878             : 
   31879           1 : SWIGINTERN PyObject *_wrap_mapObj_labelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31880             :   PyObject *resultobj = 0;
   31881             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31882           1 :   void *argp1 = 0 ;
   31883             :   int res1 = 0 ;
   31884           1 :   PyObject * obj0 = 0 ;
   31885             :   labelCacheObj *result = 0 ;
   31886             :   
   31887           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_labelcache_get",&obj0)) SWIG_fail;
   31888           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31889           1 :   if (!SWIG_IsOK(res1)) {
   31890           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_labelcache_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31891             :   }
   31892           1 :   arg1 = (struct mapObj *)(argp1);
   31893           1 :   result = (labelCacheObj *)& ((arg1)->labelcache);
   31894           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheObj, 0 |  0 );
   31895           1 :   return resultobj;
   31896           0 : fail:
   31897             :   return NULL;
   31898             : }
   31899             : 
   31900             : 
   31901           0 : SWIGINTERN PyObject *_wrap_mapObj_transparent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31902             :   PyObject *resultobj = 0;
   31903             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31904             :   int arg2 ;
   31905           0 :   void *argp1 = 0 ;
   31906             :   int res1 = 0 ;
   31907             :   int val2 ;
   31908             :   int ecode2 = 0 ;
   31909           0 :   PyObject * obj0 = 0 ;
   31910           0 :   PyObject * obj1 = 0 ;
   31911             :   
   31912           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_transparent_set",&obj0,&obj1)) SWIG_fail;
   31913           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31914           0 :   if (!SWIG_IsOK(res1)) {
   31915           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_transparent_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31916             :   }
   31917           0 :   arg1 = (struct mapObj *)(argp1);
   31918           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31919           0 :   if (!SWIG_IsOK(ecode2)) {
   31920           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_transparent_set" "', argument " "2"" of type '" "int""'");
   31921             :   } 
   31922             :   arg2 = (int)(val2);
   31923           0 :   if (arg1) (arg1)->transparent = arg2;
   31924             :   resultobj = SWIG_Py_Void();
   31925           0 :   return resultobj;
   31926           0 : fail:
   31927             :   return NULL;
   31928             : }
   31929             : 
   31930             : 
   31931           0 : SWIGINTERN PyObject *_wrap_mapObj_transparent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31932             :   PyObject *resultobj = 0;
   31933             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31934           0 :   void *argp1 = 0 ;
   31935             :   int res1 = 0 ;
   31936           0 :   PyObject * obj0 = 0 ;
   31937             :   int result;
   31938             :   
   31939           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_transparent_get",&obj0)) SWIG_fail;
   31940           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31941           0 :   if (!SWIG_IsOK(res1)) {
   31942           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_transparent_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31943             :   }
   31944           0 :   arg1 = (struct mapObj *)(argp1);
   31945           0 :   result = (int) ((arg1)->transparent);
   31946             :   resultobj = SWIG_From_int((int)(result));
   31947           0 :   return resultobj;
   31948           0 : fail:
   31949             :   return NULL;
   31950             : }
   31951             : 
   31952             : 
   31953           0 : SWIGINTERN PyObject *_wrap_mapObj_interlace_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31954             :   PyObject *resultobj = 0;
   31955             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31956             :   int arg2 ;
   31957           0 :   void *argp1 = 0 ;
   31958             :   int res1 = 0 ;
   31959             :   int val2 ;
   31960             :   int ecode2 = 0 ;
   31961           0 :   PyObject * obj0 = 0 ;
   31962           0 :   PyObject * obj1 = 0 ;
   31963             :   
   31964           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_interlace_set",&obj0,&obj1)) SWIG_fail;
   31965           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31966           0 :   if (!SWIG_IsOK(res1)) {
   31967           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_interlace_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31968             :   }
   31969           0 :   arg1 = (struct mapObj *)(argp1);
   31970           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   31971           0 :   if (!SWIG_IsOK(ecode2)) {
   31972           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_interlace_set" "', argument " "2"" of type '" "int""'");
   31973             :   } 
   31974             :   arg2 = (int)(val2);
   31975           0 :   if (arg1) (arg1)->interlace = arg2;
   31976             :   resultobj = SWIG_Py_Void();
   31977           0 :   return resultobj;
   31978           0 : fail:
   31979             :   return NULL;
   31980             : }
   31981             : 
   31982             : 
   31983           0 : SWIGINTERN PyObject *_wrap_mapObj_interlace_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   31984             :   PyObject *resultobj = 0;
   31985             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   31986           0 :   void *argp1 = 0 ;
   31987             :   int res1 = 0 ;
   31988           0 :   PyObject * obj0 = 0 ;
   31989             :   int result;
   31990             :   
   31991           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_interlace_get",&obj0)) SWIG_fail;
   31992           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   31993           0 :   if (!SWIG_IsOK(res1)) {
   31994           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_interlace_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   31995             :   }
   31996           0 :   arg1 = (struct mapObj *)(argp1);
   31997           0 :   result = (int) ((arg1)->interlace);
   31998             :   resultobj = SWIG_From_int((int)(result));
   31999           0 :   return resultobj;
   32000           0 : fail:
   32001             :   return NULL;
   32002             : }
   32003             : 
   32004             : 
   32005           0 : SWIGINTERN PyObject *_wrap_mapObj_imagequality_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32006             :   PyObject *resultobj = 0;
   32007             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32008             :   int arg2 ;
   32009           0 :   void *argp1 = 0 ;
   32010             :   int res1 = 0 ;
   32011             :   int val2 ;
   32012             :   int ecode2 = 0 ;
   32013           0 :   PyObject * obj0 = 0 ;
   32014           0 :   PyObject * obj1 = 0 ;
   32015             :   
   32016           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_imagequality_set",&obj0,&obj1)) SWIG_fail;
   32017           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32018           0 :   if (!SWIG_IsOK(res1)) {
   32019           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagequality_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32020             :   }
   32021           0 :   arg1 = (struct mapObj *)(argp1);
   32022           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   32023           0 :   if (!SWIG_IsOK(ecode2)) {
   32024           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_imagequality_set" "', argument " "2"" of type '" "int""'");
   32025             :   } 
   32026             :   arg2 = (int)(val2);
   32027           0 :   if (arg1) (arg1)->imagequality = arg2;
   32028             :   resultobj = SWIG_Py_Void();
   32029           0 :   return resultobj;
   32030           0 : fail:
   32031             :   return NULL;
   32032             : }
   32033             : 
   32034             : 
   32035           0 : SWIGINTERN PyObject *_wrap_mapObj_imagequality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32036             :   PyObject *resultobj = 0;
   32037             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32038           0 :   void *argp1 = 0 ;
   32039             :   int res1 = 0 ;
   32040           0 :   PyObject * obj0 = 0 ;
   32041             :   int result;
   32042             :   
   32043           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_imagequality_get",&obj0)) SWIG_fail;
   32044           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32045           0 :   if (!SWIG_IsOK(res1)) {
   32046           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagequality_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32047             :   }
   32048           0 :   arg1 = (struct mapObj *)(argp1);
   32049           0 :   result = (int) ((arg1)->imagequality);
   32050             :   resultobj = SWIG_From_int((int)(result));
   32051           0 :   return resultobj;
   32052           0 : fail:
   32053             :   return NULL;
   32054             : }
   32055             : 
   32056             : 
   32057           1 : SWIGINTERN PyObject *_wrap_mapObj_extent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32058             :   PyObject *resultobj = 0;
   32059             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32060             :   rectObj *arg2 = (rectObj *) 0 ;
   32061           1 :   void *argp1 = 0 ;
   32062             :   int res1 = 0 ;
   32063           1 :   void *argp2 = 0 ;
   32064             :   int res2 = 0 ;
   32065           1 :   PyObject * obj0 = 0 ;
   32066           1 :   PyObject * obj1 = 0 ;
   32067             :   
   32068           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_extent_set",&obj0,&obj1)) SWIG_fail;
   32069           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32070           1 :   if (!SWIG_IsOK(res1)) {
   32071           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_extent_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32072             :   }
   32073           1 :   arg1 = (struct mapObj *)(argp1);
   32074           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 |  0 );
   32075           1 :   if (!SWIG_IsOK(res2)) {
   32076           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_extent_set" "', argument " "2"" of type '" "rectObj *""'"); 
   32077             :   }
   32078           1 :   arg2 = (rectObj *)(argp2);
   32079           1 :   if (arg1) (arg1)->extent = *arg2;
   32080             :   resultobj = SWIG_Py_Void();
   32081           1 :   return resultobj;
   32082           0 : fail:
   32083             :   return NULL;
   32084             : }
   32085             : 
   32086             : 
   32087           1 : SWIGINTERN PyObject *_wrap_mapObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32088             :   PyObject *resultobj = 0;
   32089             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32090           1 :   void *argp1 = 0 ;
   32091             :   int res1 = 0 ;
   32092           1 :   PyObject * obj0 = 0 ;
   32093             :   rectObj *result = 0 ;
   32094             :   
   32095           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_extent_get",&obj0)) SWIG_fail;
   32096           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32097           1 :   if (!SWIG_IsOK(res1)) {
   32098           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_extent_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32099             :   }
   32100           1 :   arg1 = (struct mapObj *)(argp1);
   32101           1 :   result = (rectObj *)& ((arg1)->extent);
   32102           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   32103           1 :   return resultobj;
   32104           0 : fail:
   32105             :   return NULL;
   32106             : }
   32107             : 
   32108             : 
   32109           0 : SWIGINTERN PyObject *_wrap_mapObj_cellsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32110             :   PyObject *resultobj = 0;
   32111             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32112             :   double arg2 ;
   32113           0 :   void *argp1 = 0 ;
   32114             :   int res1 = 0 ;
   32115             :   double val2 ;
   32116             :   int ecode2 = 0 ;
   32117           0 :   PyObject * obj0 = 0 ;
   32118           0 :   PyObject * obj1 = 0 ;
   32119             :   
   32120           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_cellsize_set",&obj0,&obj1)) SWIG_fail;
   32121           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32122           0 :   if (!SWIG_IsOK(res1)) {
   32123           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_cellsize_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32124             :   }
   32125           0 :   arg1 = (struct mapObj *)(argp1);
   32126           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   32127           0 :   if (!SWIG_IsOK(ecode2)) {
   32128           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_cellsize_set" "', argument " "2"" of type '" "double""'");
   32129             :   } 
   32130           0 :   arg2 = (double)(val2);
   32131           0 :   if (arg1) (arg1)->cellsize = arg2;
   32132             :   resultobj = SWIG_Py_Void();
   32133           0 :   return resultobj;
   32134           0 : fail:
   32135             :   return NULL;
   32136             : }
   32137             : 
   32138             : 
   32139           0 : SWIGINTERN PyObject *_wrap_mapObj_cellsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32140             :   PyObject *resultobj = 0;
   32141             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32142           0 :   void *argp1 = 0 ;
   32143             :   int res1 = 0 ;
   32144           0 :   PyObject * obj0 = 0 ;
   32145             :   double result;
   32146             :   
   32147           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_cellsize_get",&obj0)) SWIG_fail;
   32148           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32149           0 :   if (!SWIG_IsOK(res1)) {
   32150           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_cellsize_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32151             :   }
   32152           0 :   arg1 = (struct mapObj *)(argp1);
   32153           0 :   result = (double) ((arg1)->cellsize);
   32154           0 :   resultobj = SWIG_From_double((double)(result));
   32155           0 :   return resultobj;
   32156           0 : fail:
   32157             :   return NULL;
   32158             : }
   32159             : 
   32160             : 
   32161           0 : SWIGINTERN PyObject *_wrap_mapObj_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32162             :   PyObject *resultobj = 0;
   32163             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32164             :   enum MS_UNITS arg2 ;
   32165           0 :   void *argp1 = 0 ;
   32166             :   int res1 = 0 ;
   32167             :   int val2 ;
   32168             :   int ecode2 = 0 ;
   32169           0 :   PyObject * obj0 = 0 ;
   32170           0 :   PyObject * obj1 = 0 ;
   32171             :   
   32172           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_units_set",&obj0,&obj1)) SWIG_fail;
   32173           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32174           0 :   if (!SWIG_IsOK(res1)) {
   32175           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_units_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32176             :   }
   32177           0 :   arg1 = (struct mapObj *)(argp1);
   32178           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   32179           0 :   if (!SWIG_IsOK(ecode2)) {
   32180           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_units_set" "', argument " "2"" of type '" "enum MS_UNITS""'");
   32181             :   } 
   32182             :   arg2 = (enum MS_UNITS)(val2);
   32183           0 :   if (arg1) (arg1)->units = arg2;
   32184             :   resultobj = SWIG_Py_Void();
   32185           0 :   return resultobj;
   32186           0 : fail:
   32187             :   return NULL;
   32188             : }
   32189             : 
   32190             : 
   32191           0 : SWIGINTERN PyObject *_wrap_mapObj_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32192             :   PyObject *resultobj = 0;
   32193             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32194           0 :   void *argp1 = 0 ;
   32195             :   int res1 = 0 ;
   32196           0 :   PyObject * obj0 = 0 ;
   32197             :   enum MS_UNITS result;
   32198             :   
   32199           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_units_get",&obj0)) SWIG_fail;
   32200           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32201           0 :   if (!SWIG_IsOK(res1)) {
   32202           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_units_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32203             :   }
   32204           0 :   arg1 = (struct mapObj *)(argp1);
   32205           0 :   result = (enum MS_UNITS) ((arg1)->units);
   32206             :   resultobj = SWIG_From_int((int)(result));
   32207           0 :   return resultobj;
   32208           0 : fail:
   32209             :   return NULL;
   32210             : }
   32211             : 
   32212             : 
   32213           0 : SWIGINTERN PyObject *_wrap_mapObj_scaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32214             :   PyObject *resultobj = 0;
   32215             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32216             :   double arg2 ;
   32217           0 :   void *argp1 = 0 ;
   32218             :   int res1 = 0 ;
   32219             :   double val2 ;
   32220             :   int ecode2 = 0 ;
   32221           0 :   PyObject * obj0 = 0 ;
   32222           0 :   PyObject * obj1 = 0 ;
   32223             :   
   32224           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_scaledenom_set",&obj0,&obj1)) SWIG_fail;
   32225           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32226           0 :   if (!SWIG_IsOK(res1)) {
   32227           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scaledenom_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32228             :   }
   32229           0 :   arg1 = (struct mapObj *)(argp1);
   32230           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   32231           0 :   if (!SWIG_IsOK(ecode2)) {
   32232           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_scaledenom_set" "', argument " "2"" of type '" "double""'");
   32233             :   } 
   32234           0 :   arg2 = (double)(val2);
   32235           0 :   if (arg1) (arg1)->scaledenom = arg2;
   32236             :   resultobj = SWIG_Py_Void();
   32237           0 :   return resultobj;
   32238           0 : fail:
   32239             :   return NULL;
   32240             : }
   32241             : 
   32242             : 
   32243           1 : SWIGINTERN PyObject *_wrap_mapObj_scaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32244             :   PyObject *resultobj = 0;
   32245             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32246           1 :   void *argp1 = 0 ;
   32247             :   int res1 = 0 ;
   32248           1 :   PyObject * obj0 = 0 ;
   32249             :   double result;
   32250             :   
   32251           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_scaledenom_get",&obj0)) SWIG_fail;
   32252           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32253           1 :   if (!SWIG_IsOK(res1)) {
   32254           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scaledenom_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32255             :   }
   32256           1 :   arg1 = (struct mapObj *)(argp1);
   32257           1 :   result = (double) ((arg1)->scaledenom);
   32258           1 :   resultobj = SWIG_From_double((double)(result));
   32259           1 :   return resultobj;
   32260           0 : fail:
   32261             :   return NULL;
   32262             : }
   32263             : 
   32264             : 
   32265           0 : SWIGINTERN PyObject *_wrap_mapObj_resolution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32266             :   PyObject *resultobj = 0;
   32267             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32268             :   double arg2 ;
   32269           0 :   void *argp1 = 0 ;
   32270             :   int res1 = 0 ;
   32271             :   double val2 ;
   32272             :   int ecode2 = 0 ;
   32273           0 :   PyObject * obj0 = 0 ;
   32274           0 :   PyObject * obj1 = 0 ;
   32275             :   
   32276           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_resolution_set",&obj0,&obj1)) SWIG_fail;
   32277           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32278           0 :   if (!SWIG_IsOK(res1)) {
   32279           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_resolution_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32280             :   }
   32281           0 :   arg1 = (struct mapObj *)(argp1);
   32282           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   32283           0 :   if (!SWIG_IsOK(ecode2)) {
   32284           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_resolution_set" "', argument " "2"" of type '" "double""'");
   32285             :   } 
   32286           0 :   arg2 = (double)(val2);
   32287           0 :   if (arg1) (arg1)->resolution = arg2;
   32288             :   resultobj = SWIG_Py_Void();
   32289           0 :   return resultobj;
   32290           0 : fail:
   32291             :   return NULL;
   32292             : }
   32293             : 
   32294             : 
   32295           0 : SWIGINTERN PyObject *_wrap_mapObj_resolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32296             :   PyObject *resultobj = 0;
   32297             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32298           0 :   void *argp1 = 0 ;
   32299             :   int res1 = 0 ;
   32300           0 :   PyObject * obj0 = 0 ;
   32301             :   double result;
   32302             :   
   32303           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_resolution_get",&obj0)) SWIG_fail;
   32304           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32305           0 :   if (!SWIG_IsOK(res1)) {
   32306           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_resolution_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32307             :   }
   32308           0 :   arg1 = (struct mapObj *)(argp1);
   32309           0 :   result = (double) ((arg1)->resolution);
   32310           0 :   resultobj = SWIG_From_double((double)(result));
   32311           0 :   return resultobj;
   32312           0 : fail:
   32313             :   return NULL;
   32314             : }
   32315             : 
   32316             : 
   32317           0 : SWIGINTERN PyObject *_wrap_mapObj_defresolution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32318             :   PyObject *resultobj = 0;
   32319             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32320             :   double arg2 ;
   32321           0 :   void *argp1 = 0 ;
   32322             :   int res1 = 0 ;
   32323             :   double val2 ;
   32324             :   int ecode2 = 0 ;
   32325           0 :   PyObject * obj0 = 0 ;
   32326           0 :   PyObject * obj1 = 0 ;
   32327             :   
   32328           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_defresolution_set",&obj0,&obj1)) SWIG_fail;
   32329           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32330           0 :   if (!SWIG_IsOK(res1)) {
   32331           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_defresolution_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32332             :   }
   32333           0 :   arg1 = (struct mapObj *)(argp1);
   32334           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   32335           0 :   if (!SWIG_IsOK(ecode2)) {
   32336           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_defresolution_set" "', argument " "2"" of type '" "double""'");
   32337             :   } 
   32338           0 :   arg2 = (double)(val2);
   32339           0 :   if (arg1) (arg1)->defresolution = arg2;
   32340             :   resultobj = SWIG_Py_Void();
   32341           0 :   return resultobj;
   32342           0 : fail:
   32343             :   return NULL;
   32344             : }
   32345             : 
   32346             : 
   32347           0 : SWIGINTERN PyObject *_wrap_mapObj_defresolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32348             :   PyObject *resultobj = 0;
   32349             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32350           0 :   void *argp1 = 0 ;
   32351             :   int res1 = 0 ;
   32352           0 :   PyObject * obj0 = 0 ;
   32353             :   double result;
   32354             :   
   32355           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_defresolution_get",&obj0)) SWIG_fail;
   32356           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32357           0 :   if (!SWIG_IsOK(res1)) {
   32358           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_defresolution_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32359             :   }
   32360           0 :   arg1 = (struct mapObj *)(argp1);
   32361           0 :   result = (double) ((arg1)->defresolution);
   32362           0 :   resultobj = SWIG_From_double((double)(result));
   32363           0 :   return resultobj;
   32364           0 : fail:
   32365             :   return NULL;
   32366             : }
   32367             : 
   32368             : 
   32369           0 : SWIGINTERN PyObject *_wrap_mapObj_shapepath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32370             :   PyObject *resultobj = 0;
   32371             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32372             :   char *arg2 = (char *) 0 ;
   32373           0 :   void *argp1 = 0 ;
   32374             :   int res1 = 0 ;
   32375             :   int res2 ;
   32376           0 :   char *buf2 = 0 ;
   32377           0 :   int alloc2 = 0 ;
   32378           0 :   PyObject * obj0 = 0 ;
   32379           0 :   PyObject * obj1 = 0 ;
   32380             :   
   32381           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_shapepath_set",&obj0,&obj1)) SWIG_fail;
   32382           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32383           0 :   if (!SWIG_IsOK(res1)) {
   32384           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_shapepath_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32385             :   }
   32386           0 :   arg1 = (struct mapObj *)(argp1);
   32387           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   32388           0 :   if (!SWIG_IsOK(res2)) {
   32389           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_shapepath_set" "', argument " "2"" of type '" "char *""'");
   32390             :   }
   32391           0 :   arg2 = (char *)(buf2);
   32392             :   {
   32393           0 :     if (arg1->shapepath) free((char*)arg1->shapepath);
   32394           0 :     if (arg2) {
   32395           0 :       arg1->shapepath = (char *) malloc(strlen(arg2)+1);
   32396             :       strcpy((char*)arg1->shapepath,arg2);
   32397             :     } else {
   32398           0 :       arg1->shapepath = 0;
   32399             :     }
   32400             :   }
   32401             :   resultobj = SWIG_Py_Void();
   32402           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32403             :   return resultobj;
   32404           0 : fail:
   32405           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32406             :   return NULL;
   32407             : }
   32408             : 
   32409             : 
   32410           0 : SWIGINTERN PyObject *_wrap_mapObj_shapepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32411             :   PyObject *resultobj = 0;
   32412             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32413           0 :   void *argp1 = 0 ;
   32414             :   int res1 = 0 ;
   32415           0 :   PyObject * obj0 = 0 ;
   32416             :   char *result = 0 ;
   32417             :   
   32418           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_shapepath_get",&obj0)) SWIG_fail;
   32419           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32420           0 :   if (!SWIG_IsOK(res1)) {
   32421           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_shapepath_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32422             :   }
   32423           0 :   arg1 = (struct mapObj *)(argp1);
   32424           0 :   result = (char *) ((arg1)->shapepath);
   32425           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   32426           0 :   return resultobj;
   32427           0 : fail:
   32428             :   return NULL;
   32429             : }
   32430             : 
   32431             : 
   32432           0 : SWIGINTERN PyObject *_wrap_mapObj_mappath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32433             :   PyObject *resultobj = 0;
   32434             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32435             :   char *arg2 = (char *) 0 ;
   32436           0 :   void *argp1 = 0 ;
   32437             :   int res1 = 0 ;
   32438             :   int res2 ;
   32439           0 :   char *buf2 = 0 ;
   32440           0 :   int alloc2 = 0 ;
   32441           0 :   PyObject * obj0 = 0 ;
   32442           0 :   PyObject * obj1 = 0 ;
   32443             :   
   32444           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_mappath_set",&obj0,&obj1)) SWIG_fail;
   32445           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32446           0 :   if (!SWIG_IsOK(res1)) {
   32447           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_mappath_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32448             :   }
   32449           0 :   arg1 = (struct mapObj *)(argp1);
   32450           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   32451           0 :   if (!SWIG_IsOK(res2)) {
   32452           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_mappath_set" "', argument " "2"" of type '" "char *""'");
   32453             :   }
   32454           0 :   arg2 = (char *)(buf2);
   32455             :   {
   32456           0 :     if (arg1->mappath) free((char*)arg1->mappath);
   32457           0 :     if (arg2) {
   32458           0 :       arg1->mappath = (char *) malloc(strlen(arg2)+1);
   32459             :       strcpy((char*)arg1->mappath,arg2);
   32460             :     } else {
   32461           0 :       arg1->mappath = 0;
   32462             :     }
   32463             :   }
   32464             :   resultobj = SWIG_Py_Void();
   32465           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32466             :   return resultobj;
   32467           0 : fail:
   32468           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32469             :   return NULL;
   32470             : }
   32471             : 
   32472             : 
   32473           0 : SWIGINTERN PyObject *_wrap_mapObj_mappath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32474             :   PyObject *resultobj = 0;
   32475             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32476           0 :   void *argp1 = 0 ;
   32477             :   int res1 = 0 ;
   32478           0 :   PyObject * obj0 = 0 ;
   32479             :   char *result = 0 ;
   32480             :   
   32481           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_mappath_get",&obj0)) SWIG_fail;
   32482           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32483           0 :   if (!SWIG_IsOK(res1)) {
   32484           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_mappath_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32485             :   }
   32486           0 :   arg1 = (struct mapObj *)(argp1);
   32487           0 :   result = (char *) ((arg1)->mappath);
   32488           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   32489           0 :   return resultobj;
   32490           0 : fail:
   32491             :   return NULL;
   32492             : }
   32493             : 
   32494             : 
   32495           0 : SWIGINTERN PyObject *_wrap_mapObj_sldurl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32496             :   PyObject *resultobj = 0;
   32497             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32498             :   char *arg2 = (char *) 0 ;
   32499           0 :   void *argp1 = 0 ;
   32500             :   int res1 = 0 ;
   32501             :   int res2 ;
   32502           0 :   char *buf2 = 0 ;
   32503           0 :   int alloc2 = 0 ;
   32504           0 :   PyObject * obj0 = 0 ;
   32505           0 :   PyObject * obj1 = 0 ;
   32506             :   
   32507           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_sldurl_set",&obj0,&obj1)) SWIG_fail;
   32508           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32509           0 :   if (!SWIG_IsOK(res1)) {
   32510           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_sldurl_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32511             :   }
   32512           0 :   arg1 = (struct mapObj *)(argp1);
   32513           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   32514           0 :   if (!SWIG_IsOK(res2)) {
   32515           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_sldurl_set" "', argument " "2"" of type '" "char *""'");
   32516             :   }
   32517           0 :   arg2 = (char *)(buf2);
   32518             :   {
   32519           0 :     if (arg1->sldurl) free((char*)arg1->sldurl);
   32520           0 :     if (arg2) {
   32521           0 :       arg1->sldurl = (char *) malloc(strlen(arg2)+1);
   32522             :       strcpy((char*)arg1->sldurl,arg2);
   32523             :     } else {
   32524           0 :       arg1->sldurl = 0;
   32525             :     }
   32526             :   }
   32527             :   resultobj = SWIG_Py_Void();
   32528           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32529             :   return resultobj;
   32530           0 : fail:
   32531           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32532             :   return NULL;
   32533             : }
   32534             : 
   32535             : 
   32536           0 : SWIGINTERN PyObject *_wrap_mapObj_sldurl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32537             :   PyObject *resultobj = 0;
   32538             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32539           0 :   void *argp1 = 0 ;
   32540             :   int res1 = 0 ;
   32541           0 :   PyObject * obj0 = 0 ;
   32542             :   char *result = 0 ;
   32543             :   
   32544           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_sldurl_get",&obj0)) SWIG_fail;
   32545           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32546           0 :   if (!SWIG_IsOK(res1)) {
   32547           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_sldurl_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32548             :   }
   32549           0 :   arg1 = (struct mapObj *)(argp1);
   32550           0 :   result = (char *) ((arg1)->sldurl);
   32551           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   32552           0 :   return resultobj;
   32553           0 : fail:
   32554             :   return NULL;
   32555             : }
   32556             : 
   32557             : 
   32558           0 : SWIGINTERN PyObject *_wrap_mapObj_imagecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32559             :   PyObject *resultobj = 0;
   32560             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32561             :   colorObj *arg2 = (colorObj *) 0 ;
   32562           0 :   void *argp1 = 0 ;
   32563             :   int res1 = 0 ;
   32564           0 :   void *argp2 = 0 ;
   32565             :   int res2 = 0 ;
   32566           0 :   PyObject * obj0 = 0 ;
   32567           0 :   PyObject * obj1 = 0 ;
   32568             :   
   32569           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_imagecolor_set",&obj0,&obj1)) SWIG_fail;
   32570           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32571           0 :   if (!SWIG_IsOK(res1)) {
   32572           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagecolor_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32573             :   }
   32574           0 :   arg1 = (struct mapObj *)(argp1);
   32575           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 |  0 );
   32576           0 :   if (!SWIG_IsOK(res2)) {
   32577           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_imagecolor_set" "', argument " "2"" of type '" "colorObj *""'"); 
   32578             :   }
   32579           0 :   arg2 = (colorObj *)(argp2);
   32580           0 :   if (arg1) (arg1)->imagecolor = *arg2;
   32581             :   resultobj = SWIG_Py_Void();
   32582           0 :   return resultobj;
   32583           0 : fail:
   32584             :   return NULL;
   32585             : }
   32586             : 
   32587             : 
   32588           0 : SWIGINTERN PyObject *_wrap_mapObj_imagecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32589             :   PyObject *resultobj = 0;
   32590             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32591           0 :   void *argp1 = 0 ;
   32592             :   int res1 = 0 ;
   32593           0 :   PyObject * obj0 = 0 ;
   32594             :   colorObj *result = 0 ;
   32595             :   
   32596           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_imagecolor_get",&obj0)) SWIG_fail;
   32597           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32598           0 :   if (!SWIG_IsOK(res1)) {
   32599           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagecolor_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32600             :   }
   32601           0 :   arg1 = (struct mapObj *)(argp1);
   32602           0 :   result = (colorObj *)& ((arg1)->imagecolor);
   32603           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 |  0 );
   32604           0 :   return resultobj;
   32605           0 : fail:
   32606             :   return NULL;
   32607             : }
   32608             : 
   32609             : 
   32610           1 : SWIGINTERN PyObject *_wrap_mapObj_numoutputformats_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32611             :   PyObject *resultobj = 0;
   32612             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32613           1 :   void *argp1 = 0 ;
   32614             :   int res1 = 0 ;
   32615           1 :   PyObject * obj0 = 0 ;
   32616             :   int result;
   32617             :   
   32618           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_numoutputformats_get",&obj0)) SWIG_fail;
   32619           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32620           1 :   if (!SWIG_IsOK(res1)) {
   32621           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_numoutputformats_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32622             :   }
   32623           1 :   arg1 = (struct mapObj *)(argp1);
   32624           1 :   result = (int) ((arg1)->numoutputformats);
   32625             :   resultobj = SWIG_From_int((int)(result));
   32626           1 :   return resultobj;
   32627           0 : fail:
   32628             :   return NULL;
   32629             : }
   32630             : 
   32631             : 
   32632           1 : SWIGINTERN PyObject *_wrap_mapObj_outputformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32633             :   PyObject *resultobj = 0;
   32634             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32635           1 :   void *argp1 = 0 ;
   32636             :   int res1 = 0 ;
   32637           1 :   PyObject * obj0 = 0 ;
   32638             :   outputFormatObj *result = 0 ;
   32639             :   
   32640           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_outputformat_get",&obj0)) SWIG_fail;
   32641           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32642           1 :   if (!SWIG_IsOK(res1)) {
   32643           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_outputformat_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32644             :   }
   32645           1 :   arg1 = (struct mapObj *)(argp1);
   32646           1 :   result = (outputFormatObj *) ((arg1)->outputformat);
   32647           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, 0 |  0 );
   32648           1 :   return resultobj;
   32649           0 : fail:
   32650             :   return NULL;
   32651             : }
   32652             : 
   32653             : 
   32654           0 : SWIGINTERN PyObject *_wrap_mapObj_imagetype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32655             :   PyObject *resultobj = 0;
   32656             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32657           0 :   void *argp1 = 0 ;
   32658             :   int res1 = 0 ;
   32659           0 :   PyObject * obj0 = 0 ;
   32660             :   char *result = 0 ;
   32661             :   
   32662           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_imagetype_get",&obj0)) SWIG_fail;
   32663           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32664           0 :   if (!SWIG_IsOK(res1)) {
   32665           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagetype_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32666             :   }
   32667           0 :   arg1 = (struct mapObj *)(argp1);
   32668           0 :   result = (char *) ((arg1)->imagetype);
   32669           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   32670           0 :   return resultobj;
   32671           0 : fail:
   32672             :   return NULL;
   32673             : }
   32674             : 
   32675             : 
   32676           0 : SWIGINTERN PyObject *_wrap_mapObj_reference_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32677             :   PyObject *resultobj = 0;
   32678             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32679           0 :   void *argp1 = 0 ;
   32680             :   int res1 = 0 ;
   32681           0 :   PyObject * obj0 = 0 ;
   32682             :   referenceMapObj *result = 0 ;
   32683             :   
   32684           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_reference_get",&obj0)) SWIG_fail;
   32685           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32686           0 :   if (!SWIG_IsOK(res1)) {
   32687           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_reference_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32688             :   }
   32689           0 :   arg1 = (struct mapObj *)(argp1);
   32690           0 :   result = (referenceMapObj *)& ((arg1)->reference);
   32691           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_referenceMapObj, 0 |  0 );
   32692           0 :   return resultobj;
   32693           0 : fail:
   32694             :   return NULL;
   32695             : }
   32696             : 
   32697             : 
   32698           0 : SWIGINTERN PyObject *_wrap_mapObj_scalebar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32699             :   PyObject *resultobj = 0;
   32700             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32701           0 :   void *argp1 = 0 ;
   32702             :   int res1 = 0 ;
   32703           0 :   PyObject * obj0 = 0 ;
   32704             :   scalebarObj *result = 0 ;
   32705             :   
   32706           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_scalebar_get",&obj0)) SWIG_fail;
   32707           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32708           0 :   if (!SWIG_IsOK(res1)) {
   32709           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scalebar_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32710             :   }
   32711           0 :   arg1 = (struct mapObj *)(argp1);
   32712           0 :   result = (scalebarObj *)& ((arg1)->scalebar);
   32713           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scalebarObj, 0 |  0 );
   32714           0 :   return resultobj;
   32715           0 : fail:
   32716             :   return NULL;
   32717             : }
   32718             : 
   32719             : 
   32720           0 : SWIGINTERN PyObject *_wrap_mapObj_legend_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32721             :   PyObject *resultobj = 0;
   32722             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32723           0 :   void *argp1 = 0 ;
   32724             :   int res1 = 0 ;
   32725           0 :   PyObject * obj0 = 0 ;
   32726             :   legendObj *result = 0 ;
   32727             :   
   32728           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_legend_get",&obj0)) SWIG_fail;
   32729           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32730           0 :   if (!SWIG_IsOK(res1)) {
   32731           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_legend_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32732             :   }
   32733           0 :   arg1 = (struct mapObj *)(argp1);
   32734           0 :   result = (legendObj *)& ((arg1)->legend);
   32735           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_legendObj, 0 |  0 );
   32736           0 :   return resultobj;
   32737           0 : fail:
   32738             :   return NULL;
   32739             : }
   32740             : 
   32741             : 
   32742           0 : SWIGINTERN PyObject *_wrap_mapObj_querymap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32743             :   PyObject *resultobj = 0;
   32744             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32745           0 :   void *argp1 = 0 ;
   32746             :   int res1 = 0 ;
   32747           0 :   PyObject * obj0 = 0 ;
   32748             :   queryMapObj *result = 0 ;
   32749             :   
   32750           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_querymap_get",&obj0)) SWIG_fail;
   32751           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32752           0 :   if (!SWIG_IsOK(res1)) {
   32753           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_querymap_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32754             :   }
   32755           0 :   arg1 = (struct mapObj *)(argp1);
   32756           0 :   result = (queryMapObj *)& ((arg1)->querymap);
   32757           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_queryMapObj, 0 |  0 );
   32758           0 :   return resultobj;
   32759           0 : fail:
   32760             :   return NULL;
   32761             : }
   32762             : 
   32763             : 
   32764           1 : SWIGINTERN PyObject *_wrap_mapObj_web_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32765             :   PyObject *resultobj = 0;
   32766             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32767           1 :   void *argp1 = 0 ;
   32768             :   int res1 = 0 ;
   32769           1 :   PyObject * obj0 = 0 ;
   32770             :   webObj *result = 0 ;
   32771             :   
   32772           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_web_get",&obj0)) SWIG_fail;
   32773           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32774           1 :   if (!SWIG_IsOK(res1)) {
   32775           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_web_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32776             :   }
   32777           1 :   arg1 = (struct mapObj *)(argp1);
   32778           1 :   result = (webObj *)& ((arg1)->web);
   32779           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_webObj, 0 |  0 );
   32780           1 :   return resultobj;
   32781           0 : fail:
   32782             :   return NULL;
   32783             : }
   32784             : 
   32785             : 
   32786           0 : SWIGINTERN PyObject *_wrap_mapObj_layerorder_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32787             :   PyObject *resultobj = 0;
   32788             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32789             :   int *arg2 = (int *) 0 ;
   32790           0 :   void *argp1 = 0 ;
   32791             :   int res1 = 0 ;
   32792           0 :   void *argp2 = 0 ;
   32793             :   int res2 = 0 ;
   32794           0 :   PyObject * obj0 = 0 ;
   32795           0 :   PyObject * obj1 = 0 ;
   32796             :   
   32797           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_layerorder_set",&obj0,&obj1)) SWIG_fail;
   32798           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32799           0 :   if (!SWIG_IsOK(res1)) {
   32800           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_layerorder_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32801             :   }
   32802           0 :   arg1 = (struct mapObj *)(argp1);
   32803           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN |  0 );
   32804           0 :   if (!SWIG_IsOK(res2)) {
   32805           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_layerorder_set" "', argument " "2"" of type '" "int *""'"); 
   32806             :   }
   32807           0 :   arg2 = (int *)(argp2);
   32808           0 :   if (arg1) (arg1)->layerorder = arg2;
   32809             :   resultobj = SWIG_Py_Void();
   32810           0 :   return resultobj;
   32811           0 : fail:
   32812             :   return NULL;
   32813             : }
   32814             : 
   32815             : 
   32816           0 : SWIGINTERN PyObject *_wrap_mapObj_layerorder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32817             :   PyObject *resultobj = 0;
   32818             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32819           0 :   void *argp1 = 0 ;
   32820             :   int res1 = 0 ;
   32821           0 :   PyObject * obj0 = 0 ;
   32822             :   int *result = 0 ;
   32823             :   
   32824           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_layerorder_get",&obj0)) SWIG_fail;
   32825           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32826           0 :   if (!SWIG_IsOK(res1)) {
   32827           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_layerorder_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32828             :   }
   32829           0 :   arg1 = (struct mapObj *)(argp1);
   32830           0 :   result = (int *) ((arg1)->layerorder);
   32831           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
   32832           0 :   return resultobj;
   32833           0 : fail:
   32834             :   return NULL;
   32835             : }
   32836             : 
   32837             : 
   32838           1 : SWIGINTERN PyObject *_wrap_mapObj_debug_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32839             :   PyObject *resultobj = 0;
   32840             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32841             :   int arg2 ;
   32842           1 :   void *argp1 = 0 ;
   32843             :   int res1 = 0 ;
   32844             :   int val2 ;
   32845             :   int ecode2 = 0 ;
   32846           1 :   PyObject * obj0 = 0 ;
   32847           1 :   PyObject * obj1 = 0 ;
   32848             :   
   32849           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_debug_set",&obj0,&obj1)) SWIG_fail;
   32850           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32851           1 :   if (!SWIG_IsOK(res1)) {
   32852           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_debug_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32853             :   }
   32854           1 :   arg1 = (struct mapObj *)(argp1);
   32855           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   32856           1 :   if (!SWIG_IsOK(ecode2)) {
   32857           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_debug_set" "', argument " "2"" of type '" "int""'");
   32858             :   } 
   32859             :   arg2 = (int)(val2);
   32860           1 :   if (arg1) (arg1)->debug = arg2;
   32861             :   resultobj = SWIG_Py_Void();
   32862           1 :   return resultobj;
   32863           0 : fail:
   32864             :   return NULL;
   32865             : }
   32866             : 
   32867             : 
   32868           0 : SWIGINTERN PyObject *_wrap_mapObj_debug_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32869             :   PyObject *resultobj = 0;
   32870             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32871           0 :   void *argp1 = 0 ;
   32872             :   int res1 = 0 ;
   32873           0 :   PyObject * obj0 = 0 ;
   32874             :   int result;
   32875             :   
   32876           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_debug_get",&obj0)) SWIG_fail;
   32877           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32878           0 :   if (!SWIG_IsOK(res1)) {
   32879           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_debug_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32880             :   }
   32881           0 :   arg1 = (struct mapObj *)(argp1);
   32882           0 :   result = (int) ((arg1)->debug);
   32883             :   resultobj = SWIG_From_int((int)(result));
   32884           0 :   return resultobj;
   32885           0 : fail:
   32886             :   return NULL;
   32887             : }
   32888             : 
   32889             : 
   32890           0 : SWIGINTERN PyObject *_wrap_mapObj_datapattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32891             :   PyObject *resultobj = 0;
   32892             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32893             :   char *arg2 = (char *) 0 ;
   32894           0 :   void *argp1 = 0 ;
   32895             :   int res1 = 0 ;
   32896             :   int res2 ;
   32897           0 :   char *buf2 = 0 ;
   32898           0 :   int alloc2 = 0 ;
   32899           0 :   PyObject * obj0 = 0 ;
   32900           0 :   PyObject * obj1 = 0 ;
   32901             :   
   32902           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_datapattern_set",&obj0,&obj1)) SWIG_fail;
   32903           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32904           0 :   if (!SWIG_IsOK(res1)) {
   32905           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_datapattern_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32906             :   }
   32907           0 :   arg1 = (struct mapObj *)(argp1);
   32908           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   32909           0 :   if (!SWIG_IsOK(res2)) {
   32910           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_datapattern_set" "', argument " "2"" of type '" "char *""'");
   32911             :   }
   32912           0 :   arg2 = (char *)(buf2);
   32913             :   {
   32914           0 :     if (arg1->datapattern) free((char*)arg1->datapattern);
   32915           0 :     if (arg2) {
   32916           0 :       arg1->datapattern = (char *) malloc(strlen(arg2)+1);
   32917             :       strcpy((char*)arg1->datapattern,arg2);
   32918             :     } else {
   32919           0 :       arg1->datapattern = 0;
   32920             :     }
   32921             :   }
   32922             :   resultobj = SWIG_Py_Void();
   32923           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32924             :   return resultobj;
   32925           0 : fail:
   32926           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32927             :   return NULL;
   32928             : }
   32929             : 
   32930             : 
   32931           0 : SWIGINTERN PyObject *_wrap_mapObj_datapattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32932             :   PyObject *resultobj = 0;
   32933             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32934           0 :   void *argp1 = 0 ;
   32935             :   int res1 = 0 ;
   32936           0 :   PyObject * obj0 = 0 ;
   32937             :   char *result = 0 ;
   32938             :   
   32939           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_datapattern_get",&obj0)) SWIG_fail;
   32940           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32941           0 :   if (!SWIG_IsOK(res1)) {
   32942           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_datapattern_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32943             :   }
   32944           0 :   arg1 = (struct mapObj *)(argp1);
   32945           0 :   result = (char *) ((arg1)->datapattern);
   32946           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   32947           0 :   return resultobj;
   32948           0 : fail:
   32949             :   return NULL;
   32950             : }
   32951             : 
   32952             : 
   32953           0 : SWIGINTERN PyObject *_wrap_mapObj_templatepattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32954             :   PyObject *resultobj = 0;
   32955             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32956             :   char *arg2 = (char *) 0 ;
   32957           0 :   void *argp1 = 0 ;
   32958             :   int res1 = 0 ;
   32959             :   int res2 ;
   32960           0 :   char *buf2 = 0 ;
   32961           0 :   int alloc2 = 0 ;
   32962           0 :   PyObject * obj0 = 0 ;
   32963           0 :   PyObject * obj1 = 0 ;
   32964             :   
   32965           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_templatepattern_set",&obj0,&obj1)) SWIG_fail;
   32966           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   32967           0 :   if (!SWIG_IsOK(res1)) {
   32968           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_templatepattern_set" "', argument " "1"" of type '" "struct mapObj *""'"); 
   32969             :   }
   32970           0 :   arg1 = (struct mapObj *)(argp1);
   32971           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   32972           0 :   if (!SWIG_IsOK(res2)) {
   32973           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_templatepattern_set" "', argument " "2"" of type '" "char *""'");
   32974             :   }
   32975           0 :   arg2 = (char *)(buf2);
   32976             :   {
   32977           0 :     if (arg1->templatepattern) free((char*)arg1->templatepattern);
   32978           0 :     if (arg2) {
   32979           0 :       arg1->templatepattern = (char *) malloc(strlen(arg2)+1);
   32980             :       strcpy((char*)arg1->templatepattern,arg2);
   32981             :     } else {
   32982           0 :       arg1->templatepattern = 0;
   32983             :     }
   32984             :   }
   32985             :   resultobj = SWIG_Py_Void();
   32986           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32987             :   return resultobj;
   32988           0 : fail:
   32989           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   32990             :   return NULL;
   32991             : }
   32992             : 
   32993             : 
   32994           0 : SWIGINTERN PyObject *_wrap_mapObj_templatepattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   32995             :   PyObject *resultobj = 0;
   32996             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   32997           0 :   void *argp1 = 0 ;
   32998             :   int res1 = 0 ;
   32999           0 :   PyObject * obj0 = 0 ;
   33000             :   char *result = 0 ;
   33001             :   
   33002           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_templatepattern_get",&obj0)) SWIG_fail;
   33003           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33004           0 :   if (!SWIG_IsOK(res1)) {
   33005           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_templatepattern_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33006             :   }
   33007           0 :   arg1 = (struct mapObj *)(argp1);
   33008           0 :   result = (char *) ((arg1)->templatepattern);
   33009           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   33010           0 :   return resultobj;
   33011           0 : fail:
   33012             :   return NULL;
   33013             : }
   33014             : 
   33015             : 
   33016           0 : SWIGINTERN PyObject *_wrap_mapObj_configoptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33017             :   PyObject *resultobj = 0;
   33018             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33019           0 :   void *argp1 = 0 ;
   33020             :   int res1 = 0 ;
   33021           0 :   PyObject * obj0 = 0 ;
   33022             :   hashTableObj *result = 0 ;
   33023             :   
   33024           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_configoptions_get",&obj0)) SWIG_fail;
   33025           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33026           0 :   if (!SWIG_IsOK(res1)) {
   33027           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_configoptions_get" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33028             :   }
   33029           0 :   arg1 = (struct mapObj *)(argp1);
   33030           0 :   result = (hashTableObj *)& ((arg1)->configoptions);
   33031           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 |  0 );
   33032           0 :   return resultobj;
   33033           0 : fail:
   33034             :   return NULL;
   33035             : }
   33036             : 
   33037             : 
   33038           1 : SWIGINTERN PyObject *_wrap_new_mapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33039             :   PyObject *resultobj = 0;
   33040             :   char *arg1 = (char *) "" ;
   33041             :   int res1 ;
   33042           1 :   char *buf1 = 0 ;
   33043           1 :   int alloc1 = 0 ;
   33044           1 :   PyObject * obj0 = 0 ;
   33045             :   struct mapObj *result = 0 ;
   33046             :   
   33047           1 :   if (!PyArg_ParseTuple(args,(char *)"|O:new_mapObj",&obj0)) SWIG_fail;
   33048           1 :   if (obj0) {
   33049           1 :     res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   33050           1 :     if (!SWIG_IsOK(res1)) {
   33051           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mapObj" "', argument " "1"" of type '" "char *""'");
   33052             :     }
   33053           1 :     arg1 = (char *)(buf1);
   33054             :   }
   33055             :   {
   33056           1 :     result = (struct mapObj *)new_mapObj(arg1); {
   33057           1 :       errorObj *ms_error = msGetErrorObj();
   33058             :       
   33059           1 :       switch(ms_error->code) {
   33060             :       case MS_NOERR:
   33061             :         break;
   33062           0 :       case MS_NOTFOUND:
   33063           0 :         msResetErrorList();
   33064           0 :         break;
   33065             :       case -1:
   33066             :         break;
   33067           0 :       case MS_IOERR:
   33068           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33069           0 :           _raise_ms_exception();
   33070           0 :           msResetErrorList();
   33071           0 :           return NULL;
   33072             :         }
   33073             :       default:
   33074           0 :         _raise_ms_exception();
   33075           0 :         msResetErrorList();
   33076           0 :         return NULL;
   33077             :       }
   33078             :       
   33079             :     }
   33080             :   }
   33081           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, SWIG_POINTER_NEW |  0 );
   33082           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   33083             :   return resultobj;
   33084           0 : fail:
   33085           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   33086             :   return NULL;
   33087             : }
   33088             : 
   33089             : 
   33090           1 : SWIGINTERN PyObject *_wrap_delete_mapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33091             :   PyObject *resultobj = 0;
   33092             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33093           1 :   void *argp1 = 0 ;
   33094             :   int res1 = 0 ;
   33095           1 :   PyObject * obj0 = 0 ;
   33096             :   
   33097           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_mapObj",&obj0)) SWIG_fail;
   33098           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, SWIG_POINTER_DISOWN |  0 );
   33099           1 :   if (!SWIG_IsOK(res1)) {
   33100           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mapObj" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33101             :   }
   33102           1 :   arg1 = (struct mapObj *)(argp1);
   33103             :   {
   33104             :     delete_mapObj(arg1); {
   33105           1 :       errorObj *ms_error = msGetErrorObj();
   33106             :       
   33107           1 :       switch(ms_error->code) {
   33108             :       case MS_NOERR:
   33109             :         break;
   33110           0 :       case MS_NOTFOUND:
   33111           0 :         msResetErrorList();
   33112           0 :         break;
   33113             :       case -1:
   33114             :         break;
   33115           0 :       case MS_IOERR:
   33116           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33117           0 :           _raise_ms_exception();
   33118           0 :           msResetErrorList();
   33119           0 :           return NULL;
   33120             :         }
   33121             :       default:
   33122           0 :         _raise_ms_exception();
   33123           0 :         msResetErrorList();
   33124           0 :         return NULL;
   33125             :       }
   33126             :       
   33127             :     }
   33128             :   }
   33129             :   resultobj = SWIG_Py_Void();
   33130           1 :   return resultobj;
   33131           0 : fail:
   33132             :   return NULL;
   33133             : }
   33134             : 
   33135             : 
   33136           1 : SWIGINTERN PyObject *_wrap_mapObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33137             :   PyObject *resultobj = 0;
   33138             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33139           1 :   void *argp1 = 0 ;
   33140             :   int res1 = 0 ;
   33141           1 :   PyObject * obj0 = 0 ;
   33142             :   mapObj *result = 0 ;
   33143             :   
   33144           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_clone",&obj0)) SWIG_fail;
   33145           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33146           1 :   if (!SWIG_IsOK(res1)) {
   33147           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_clone" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33148             :   }
   33149           1 :   arg1 = (struct mapObj *)(argp1);
   33150             :   {
   33151           1 :     result = (mapObj *)mapObj_clone(arg1); {
   33152           1 :       errorObj *ms_error = msGetErrorObj();
   33153             :       
   33154           1 :       switch(ms_error->code) {
   33155             :       case MS_NOERR:
   33156             :         break;
   33157           0 :       case MS_NOTFOUND:
   33158           0 :         msResetErrorList();
   33159           0 :         break;
   33160             :       case -1:
   33161             :         break;
   33162           0 :       case MS_IOERR:
   33163           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33164           0 :           _raise_ms_exception();
   33165           0 :           msResetErrorList();
   33166           0 :           return NULL;
   33167             :         }
   33168             :       default:
   33169           0 :         _raise_ms_exception();
   33170           0 :         msResetErrorList();
   33171           0 :         return NULL;
   33172             :       }
   33173             :       
   33174             :     }
   33175             :   }
   33176           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, SWIG_POINTER_OWN |  0 );
   33177           1 :   return resultobj;
   33178           0 : fail:
   33179             :   return NULL;
   33180             : }
   33181             : 
   33182             : 
   33183           1 : SWIGINTERN PyObject *_wrap_mapObj_insertLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33184             :   PyObject *resultobj = 0;
   33185             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33186             :   layerObj *arg2 = (layerObj *) 0 ;
   33187             :   int arg3 = (int) -1 ;
   33188           1 :   void *argp1 = 0 ;
   33189             :   int res1 = 0 ;
   33190           1 :   void *argp2 = 0 ;
   33191             :   int res2 = 0 ;
   33192             :   int val3 ;
   33193             :   int ecode3 = 0 ;
   33194           1 :   PyObject * obj0 = 0 ;
   33195           1 :   PyObject * obj1 = 0 ;
   33196           1 :   PyObject * obj2 = 0 ;
   33197             :   int result;
   33198             :   
   33199           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_insertLayer",&obj0,&obj1,&obj2)) SWIG_fail;
   33200           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33201           1 :   if (!SWIG_IsOK(res1)) {
   33202           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_insertLayer" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33203             :   }
   33204           1 :   arg1 = (struct mapObj *)(argp1);
   33205           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_layerObj, 0 |  0 );
   33206           1 :   if (!SWIG_IsOK(res2)) {
   33207           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_insertLayer" "', argument " "2"" of type '" "layerObj *""'"); 
   33208             :   }
   33209           1 :   arg2 = (layerObj *)(argp2);
   33210           1 :   if (obj2) {
   33211             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   33212           1 :     if (!SWIG_IsOK(ecode3)) {
   33213           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_insertLayer" "', argument " "3"" of type '" "int""'");
   33214             :     } 
   33215             :     arg3 = (int)(val3);
   33216             :   }
   33217             :   {
   33218             :     result = (int)mapObj_insertLayer(arg1,arg2,arg3); {
   33219           1 :       errorObj *ms_error = msGetErrorObj();
   33220             :       
   33221           1 :       switch(ms_error->code) {
   33222             :       case MS_NOERR:
   33223             :         break;
   33224           0 :       case MS_NOTFOUND:
   33225           0 :         msResetErrorList();
   33226           0 :         break;
   33227             :       case -1:
   33228             :         break;
   33229           0 :       case MS_IOERR:
   33230           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33231           0 :           _raise_ms_exception();
   33232           0 :           msResetErrorList();
   33233           0 :           return NULL;
   33234             :         }
   33235             :       default:
   33236           1 :         _raise_ms_exception();
   33237           1 :         msResetErrorList();
   33238           1 :         return NULL;
   33239             :       }
   33240             :       
   33241             :     }
   33242             :   }
   33243             :   resultobj = SWIG_From_int((int)(result));
   33244           1 :   return resultobj;
   33245           0 : fail:
   33246             :   return NULL;
   33247             : }
   33248             : 
   33249             : 
   33250           1 : SWIGINTERN PyObject *_wrap_mapObj_removeLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33251             :   PyObject *resultobj = 0;
   33252             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33253             :   int arg2 ;
   33254           1 :   void *argp1 = 0 ;
   33255             :   int res1 = 0 ;
   33256             :   int val2 ;
   33257             :   int ecode2 = 0 ;
   33258           1 :   PyObject * obj0 = 0 ;
   33259           1 :   PyObject * obj1 = 0 ;
   33260             :   layerObj *result = 0 ;
   33261             :   
   33262           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_removeLayer",&obj0,&obj1)) SWIG_fail;
   33263           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33264           1 :   if (!SWIG_IsOK(res1)) {
   33265           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_removeLayer" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33266             :   }
   33267           1 :   arg1 = (struct mapObj *)(argp1);
   33268           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   33269           1 :   if (!SWIG_IsOK(ecode2)) {
   33270           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_removeLayer" "', argument " "2"" of type '" "int""'");
   33271             :   } 
   33272             :   arg2 = (int)(val2);
   33273             :   {
   33274             :     result = (layerObj *)mapObj_removeLayer(arg1,arg2); {
   33275           1 :       errorObj *ms_error = msGetErrorObj();
   33276             :       
   33277           1 :       switch(ms_error->code) {
   33278             :       case MS_NOERR:
   33279             :         break;
   33280           0 :       case MS_NOTFOUND:
   33281           0 :         msResetErrorList();
   33282           0 :         break;
   33283             :       case -1:
   33284             :         break;
   33285           0 :       case MS_IOERR:
   33286           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33287           0 :           _raise_ms_exception();
   33288           0 :           msResetErrorList();
   33289           0 :           return NULL;
   33290             :         }
   33291             :       default:
   33292           0 :         _raise_ms_exception();
   33293           0 :         msResetErrorList();
   33294           0 :         return NULL;
   33295             :       }
   33296             :       
   33297             :     }
   33298             :   }
   33299           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN |  0 );
   33300           1 :   return resultobj;
   33301           0 : fail:
   33302             :   return NULL;
   33303             : }
   33304             : 
   33305             : 
   33306           1 : SWIGINTERN PyObject *_wrap_mapObj_setExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33307             :   PyObject *resultobj = 0;
   33308             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33309             :   double arg2 ;
   33310             :   double arg3 ;
   33311             :   double arg4 ;
   33312             :   double arg5 ;
   33313           1 :   void *argp1 = 0 ;
   33314             :   int res1 = 0 ;
   33315             :   double val2 ;
   33316             :   int ecode2 = 0 ;
   33317             :   double val3 ;
   33318             :   int ecode3 = 0 ;
   33319             :   double val4 ;
   33320             :   int ecode4 = 0 ;
   33321             :   double val5 ;
   33322             :   int ecode5 = 0 ;
   33323           1 :   PyObject * obj0 = 0 ;
   33324           1 :   PyObject * obj1 = 0 ;
   33325           1 :   PyObject * obj2 = 0 ;
   33326           1 :   PyObject * obj3 = 0 ;
   33327           1 :   PyObject * obj4 = 0 ;
   33328             :   int result;
   33329             :   
   33330           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:mapObj_setExtent",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   33331           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33332           1 :   if (!SWIG_IsOK(res1)) {
   33333           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setExtent" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33334             :   }
   33335           1 :   arg1 = (struct mapObj *)(argp1);
   33336           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   33337           1 :   if (!SWIG_IsOK(ecode2)) {
   33338           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_setExtent" "', argument " "2"" of type '" "double""'");
   33339             :   } 
   33340           1 :   arg2 = (double)(val2);
   33341           1 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   33342           1 :   if (!SWIG_IsOK(ecode3)) {
   33343           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_setExtent" "', argument " "3"" of type '" "double""'");
   33344             :   } 
   33345           1 :   arg3 = (double)(val3);
   33346           1 :   ecode4 = SWIG_AsVal_double(obj3, &val4);
   33347           1 :   if (!SWIG_IsOK(ecode4)) {
   33348           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_setExtent" "', argument " "4"" of type '" "double""'");
   33349             :   } 
   33350           1 :   arg4 = (double)(val4);
   33351           1 :   ecode5 = SWIG_AsVal_double(obj4, &val5);
   33352           1 :   if (!SWIG_IsOK(ecode5)) {
   33353           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_setExtent" "', argument " "5"" of type '" "double""'");
   33354             :   } 
   33355           1 :   arg5 = (double)(val5);
   33356             :   {
   33357             :     result = (int)mapObj_setExtent(arg1,arg2,arg3,arg4,arg5); {
   33358           1 :       errorObj *ms_error = msGetErrorObj();
   33359             :       
   33360           1 :       switch(ms_error->code) {
   33361             :       case MS_NOERR:
   33362             :         break;
   33363           0 :       case MS_NOTFOUND:
   33364           0 :         msResetErrorList();
   33365           0 :         break;
   33366             :       case -1:
   33367             :         break;
   33368           0 :       case MS_IOERR:
   33369           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33370           0 :           _raise_ms_exception();
   33371           0 :           msResetErrorList();
   33372           0 :           return NULL;
   33373             :         }
   33374             :       default:
   33375           1 :         _raise_ms_exception();
   33376           1 :         msResetErrorList();
   33377           1 :         return NULL;
   33378             :       }
   33379             :       
   33380             :     }
   33381             :   }
   33382             :   resultobj = SWIG_From_int((int)(result));
   33383           1 :   return resultobj;
   33384           0 : fail:
   33385             :   return NULL;
   33386             : }
   33387             : 
   33388             : 
   33389           0 : SWIGINTERN PyObject *_wrap_mapObj_offsetExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33390             :   PyObject *resultobj = 0;
   33391             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33392             :   double arg2 ;
   33393             :   double arg3 ;
   33394           0 :   void *argp1 = 0 ;
   33395             :   int res1 = 0 ;
   33396             :   double val2 ;
   33397             :   int ecode2 = 0 ;
   33398             :   double val3 ;
   33399             :   int ecode3 = 0 ;
   33400           0 :   PyObject * obj0 = 0 ;
   33401           0 :   PyObject * obj1 = 0 ;
   33402           0 :   PyObject * obj2 = 0 ;
   33403             :   int result;
   33404             :   
   33405           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_offsetExtent",&obj0,&obj1,&obj2)) SWIG_fail;
   33406           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33407           0 :   if (!SWIG_IsOK(res1)) {
   33408           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_offsetExtent" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33409             :   }
   33410           0 :   arg1 = (struct mapObj *)(argp1);
   33411           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   33412           0 :   if (!SWIG_IsOK(ecode2)) {
   33413           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_offsetExtent" "', argument " "2"" of type '" "double""'");
   33414             :   } 
   33415           0 :   arg2 = (double)(val2);
   33416           0 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   33417           0 :   if (!SWIG_IsOK(ecode3)) {
   33418           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_offsetExtent" "', argument " "3"" of type '" "double""'");
   33419             :   } 
   33420           0 :   arg3 = (double)(val3);
   33421             :   {
   33422             :     result = (int)mapObj_offsetExtent(arg1,arg2,arg3); {
   33423           0 :       errorObj *ms_error = msGetErrorObj();
   33424             :       
   33425           0 :       switch(ms_error->code) {
   33426             :       case MS_NOERR:
   33427             :         break;
   33428           0 :       case MS_NOTFOUND:
   33429           0 :         msResetErrorList();
   33430           0 :         break;
   33431             :       case -1:
   33432             :         break;
   33433           0 :       case MS_IOERR:
   33434           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33435           0 :           _raise_ms_exception();
   33436           0 :           msResetErrorList();
   33437           0 :           return NULL;
   33438             :         }
   33439             :       default:
   33440           0 :         _raise_ms_exception();
   33441           0 :         msResetErrorList();
   33442           0 :         return NULL;
   33443             :       }
   33444             :       
   33445             :     }
   33446             :   }
   33447             :   resultobj = SWIG_From_int((int)(result));
   33448           0 :   return resultobj;
   33449           0 : fail:
   33450             :   return NULL;
   33451             : }
   33452             : 
   33453             : 
   33454           0 : SWIGINTERN PyObject *_wrap_mapObj_scaleExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33455             :   PyObject *resultobj = 0;
   33456             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33457             :   double arg2 ;
   33458             :   double arg3 ;
   33459             :   double arg4 ;
   33460           0 :   void *argp1 = 0 ;
   33461             :   int res1 = 0 ;
   33462             :   double val2 ;
   33463             :   int ecode2 = 0 ;
   33464             :   double val3 ;
   33465             :   int ecode3 = 0 ;
   33466             :   double val4 ;
   33467             :   int ecode4 = 0 ;
   33468           0 :   PyObject * obj0 = 0 ;
   33469           0 :   PyObject * obj1 = 0 ;
   33470           0 :   PyObject * obj2 = 0 ;
   33471           0 :   PyObject * obj3 = 0 ;
   33472             :   int result;
   33473             :   
   33474           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_scaleExtent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   33475           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33476           0 :   if (!SWIG_IsOK(res1)) {
   33477           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scaleExtent" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33478             :   }
   33479           0 :   arg1 = (struct mapObj *)(argp1);
   33480           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   33481           0 :   if (!SWIG_IsOK(ecode2)) {
   33482           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_scaleExtent" "', argument " "2"" of type '" "double""'");
   33483             :   } 
   33484           0 :   arg2 = (double)(val2);
   33485           0 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   33486           0 :   if (!SWIG_IsOK(ecode3)) {
   33487           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_scaleExtent" "', argument " "3"" of type '" "double""'");
   33488             :   } 
   33489           0 :   arg3 = (double)(val3);
   33490           0 :   ecode4 = SWIG_AsVal_double(obj3, &val4);
   33491           0 :   if (!SWIG_IsOK(ecode4)) {
   33492           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_scaleExtent" "', argument " "4"" of type '" "double""'");
   33493             :   } 
   33494           0 :   arg4 = (double)(val4);
   33495             :   {
   33496             :     result = (int)mapObj_scaleExtent(arg1,arg2,arg3,arg4); {
   33497           0 :       errorObj *ms_error = msGetErrorObj();
   33498             :       
   33499           0 :       switch(ms_error->code) {
   33500             :       case MS_NOERR:
   33501             :         break;
   33502           0 :       case MS_NOTFOUND:
   33503           0 :         msResetErrorList();
   33504           0 :         break;
   33505             :       case -1:
   33506             :         break;
   33507           0 :       case MS_IOERR:
   33508           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33509           0 :           _raise_ms_exception();
   33510           0 :           msResetErrorList();
   33511           0 :           return NULL;
   33512             :         }
   33513             :       default:
   33514           0 :         _raise_ms_exception();
   33515           0 :         msResetErrorList();
   33516           0 :         return NULL;
   33517             :       }
   33518             :       
   33519             :     }
   33520             :   }
   33521             :   resultobj = SWIG_From_int((int)(result));
   33522           0 :   return resultobj;
   33523           0 : fail:
   33524             :   return NULL;
   33525             : }
   33526             : 
   33527             : 
   33528           0 : SWIGINTERN PyObject *_wrap_mapObj_setCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33529             :   PyObject *resultobj = 0;
   33530             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33531             :   pointObj *arg2 = (pointObj *) 0 ;
   33532           0 :   void *argp1 = 0 ;
   33533             :   int res1 = 0 ;
   33534           0 :   void *argp2 = 0 ;
   33535             :   int res2 = 0 ;
   33536           0 :   PyObject * obj0 = 0 ;
   33537           0 :   PyObject * obj1 = 0 ;
   33538             :   int result;
   33539             :   
   33540           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setCenter",&obj0,&obj1)) SWIG_fail;
   33541           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33542           0 :   if (!SWIG_IsOK(res1)) {
   33543           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setCenter" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33544             :   }
   33545           0 :   arg1 = (struct mapObj *)(argp1);
   33546           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   33547           0 :   if (!SWIG_IsOK(res2)) {
   33548           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setCenter" "', argument " "2"" of type '" "pointObj *""'"); 
   33549             :   }
   33550           0 :   arg2 = (pointObj *)(argp2);
   33551             :   {
   33552             :     result = (int)mapObj_setCenter(arg1,arg2); {
   33553           0 :       errorObj *ms_error = msGetErrorObj();
   33554             :       
   33555           0 :       switch(ms_error->code) {
   33556             :       case MS_NOERR:
   33557             :         break;
   33558           0 :       case MS_NOTFOUND:
   33559           0 :         msResetErrorList();
   33560           0 :         break;
   33561             :       case -1:
   33562             :         break;
   33563           0 :       case MS_IOERR:
   33564           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33565           0 :           _raise_ms_exception();
   33566           0 :           msResetErrorList();
   33567           0 :           return NULL;
   33568             :         }
   33569             :       default:
   33570           0 :         _raise_ms_exception();
   33571           0 :         msResetErrorList();
   33572           0 :         return NULL;
   33573             :       }
   33574             :       
   33575             :     }
   33576             :   }
   33577             :   resultobj = SWIG_From_int((int)(result));
   33578           0 :   return resultobj;
   33579           0 : fail:
   33580             :   return NULL;
   33581             : }
   33582             : 
   33583             : 
   33584           1 : SWIGINTERN PyObject *_wrap_mapObj_setSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33585             :   PyObject *resultobj = 0;
   33586             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33587             :   int arg2 ;
   33588             :   int arg3 ;
   33589           1 :   void *argp1 = 0 ;
   33590             :   int res1 = 0 ;
   33591             :   int val2 ;
   33592             :   int ecode2 = 0 ;
   33593             :   int val3 ;
   33594             :   int ecode3 = 0 ;
   33595           1 :   PyObject * obj0 = 0 ;
   33596           1 :   PyObject * obj1 = 0 ;
   33597           1 :   PyObject * obj2 = 0 ;
   33598             :   int result;
   33599             :   
   33600           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_setSize",&obj0,&obj1,&obj2)) SWIG_fail;
   33601           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33602           1 :   if (!SWIG_IsOK(res1)) {
   33603           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setSize" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33604             :   }
   33605           1 :   arg1 = (struct mapObj *)(argp1);
   33606           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   33607           1 :   if (!SWIG_IsOK(ecode2)) {
   33608           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_setSize" "', argument " "2"" of type '" "int""'");
   33609             :   } 
   33610             :   arg2 = (int)(val2);
   33611           1 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   33612           1 :   if (!SWIG_IsOK(ecode3)) {
   33613           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_setSize" "', argument " "3"" of type '" "int""'");
   33614             :   } 
   33615             :   arg3 = (int)(val3);
   33616             :   {
   33617             :     result = (int)mapObj_setSize(arg1,arg2,arg3); {
   33618           1 :       errorObj *ms_error = msGetErrorObj();
   33619             :       
   33620           1 :       switch(ms_error->code) {
   33621             :       case MS_NOERR:
   33622             :         break;
   33623           0 :       case MS_NOTFOUND:
   33624           0 :         msResetErrorList();
   33625           0 :         break;
   33626             :       case -1:
   33627             :         break;
   33628           0 :       case MS_IOERR:
   33629           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33630           0 :           _raise_ms_exception();
   33631           0 :           msResetErrorList();
   33632           0 :           return NULL;
   33633             :         }
   33634             :       default:
   33635           0 :         _raise_ms_exception();
   33636           0 :         msResetErrorList();
   33637           0 :         return NULL;
   33638             :       }
   33639             :       
   33640             :     }
   33641             :   }
   33642             :   resultobj = SWIG_From_int((int)(result));
   33643           1 :   return resultobj;
   33644           0 : fail:
   33645             :   return NULL;
   33646             : }
   33647             : 
   33648             : 
   33649           0 : SWIGINTERN PyObject *_wrap_mapObj_pixelToGeoref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33650             :   PyObject *resultobj = 0;
   33651             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33652             :   double arg2 ;
   33653             :   double arg3 ;
   33654             :   pointObj *arg4 = (pointObj *) 0 ;
   33655           0 :   void *argp1 = 0 ;
   33656             :   int res1 = 0 ;
   33657             :   double val2 ;
   33658             :   int ecode2 = 0 ;
   33659             :   double val3 ;
   33660             :   int ecode3 = 0 ;
   33661           0 :   void *argp4 = 0 ;
   33662             :   int res4 = 0 ;
   33663           0 :   PyObject * obj0 = 0 ;
   33664           0 :   PyObject * obj1 = 0 ;
   33665           0 :   PyObject * obj2 = 0 ;
   33666           0 :   PyObject * obj3 = 0 ;
   33667             :   
   33668           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_pixelToGeoref",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   33669           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33670           0 :   if (!SWIG_IsOK(res1)) {
   33671           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_pixelToGeoref" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33672             :   }
   33673           0 :   arg1 = (struct mapObj *)(argp1);
   33674           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   33675           0 :   if (!SWIG_IsOK(ecode2)) {
   33676           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_pixelToGeoref" "', argument " "2"" of type '" "double""'");
   33677             :   } 
   33678           0 :   arg2 = (double)(val2);
   33679           0 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   33680           0 :   if (!SWIG_IsOK(ecode3)) {
   33681           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_pixelToGeoref" "', argument " "3"" of type '" "double""'");
   33682             :   } 
   33683           0 :   arg3 = (double)(val3);
   33684           0 :   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_pointObj, 0 |  0 );
   33685           0 :   if (!SWIG_IsOK(res4)) {
   33686           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "mapObj_pixelToGeoref" "', argument " "4"" of type '" "pointObj *""'"); 
   33687             :   }
   33688           0 :   arg4 = (pointObj *)(argp4);
   33689             :   {
   33690             :     mapObj_pixelToGeoref(arg1,arg2,arg3,arg4); {
   33691           0 :       errorObj *ms_error = msGetErrorObj();
   33692             :       
   33693           0 :       switch(ms_error->code) {
   33694             :       case MS_NOERR:
   33695             :         break;
   33696           0 :       case MS_NOTFOUND:
   33697           0 :         msResetErrorList();
   33698           0 :         break;
   33699             :       case -1:
   33700             :         break;
   33701           0 :       case MS_IOERR:
   33702           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33703           0 :           _raise_ms_exception();
   33704           0 :           msResetErrorList();
   33705           0 :           return NULL;
   33706             :         }
   33707             :       default:
   33708           0 :         _raise_ms_exception();
   33709           0 :         msResetErrorList();
   33710           0 :         return NULL;
   33711             :       }
   33712             :       
   33713             :     }
   33714             :   }
   33715             :   resultobj = SWIG_Py_Void();
   33716           0 :   return resultobj;
   33717           0 : fail:
   33718             :   return NULL;
   33719             : }
   33720             : 
   33721             : 
   33722           0 : SWIGINTERN PyObject *_wrap_mapObj_getRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33723             :   PyObject *resultobj = 0;
   33724             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33725           0 :   void *argp1 = 0 ;
   33726             :   int res1 = 0 ;
   33727           0 :   PyObject * obj0 = 0 ;
   33728             :   double result;
   33729             :   
   33730           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getRotation",&obj0)) SWIG_fail;
   33731           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33732           0 :   if (!SWIG_IsOK(res1)) {
   33733           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getRotation" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33734             :   }
   33735           0 :   arg1 = (struct mapObj *)(argp1);
   33736             :   {
   33737           0 :     result = (double)mapObj_getRotation(arg1); {
   33738           0 :       errorObj *ms_error = msGetErrorObj();
   33739             :       
   33740           0 :       switch(ms_error->code) {
   33741             :       case MS_NOERR:
   33742             :         break;
   33743           0 :       case MS_NOTFOUND:
   33744           0 :         msResetErrorList();
   33745           0 :         break;
   33746             :       case -1:
   33747             :         break;
   33748           0 :       case MS_IOERR:
   33749           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33750           0 :           _raise_ms_exception();
   33751           0 :           msResetErrorList();
   33752           0 :           return NULL;
   33753             :         }
   33754             :       default:
   33755           0 :         _raise_ms_exception();
   33756           0 :         msResetErrorList();
   33757           0 :         return NULL;
   33758             :       }
   33759             :       
   33760             :     }
   33761             :   }
   33762           0 :   resultobj = SWIG_From_double((double)(result));
   33763           0 :   return resultobj;
   33764           0 : fail:
   33765             :   return NULL;
   33766             : }
   33767             : 
   33768             : 
   33769           0 : SWIGINTERN PyObject *_wrap_mapObj_setRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33770             :   PyObject *resultobj = 0;
   33771             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33772             :   double arg2 ;
   33773           0 :   void *argp1 = 0 ;
   33774             :   int res1 = 0 ;
   33775             :   double val2 ;
   33776             :   int ecode2 = 0 ;
   33777           0 :   PyObject * obj0 = 0 ;
   33778           0 :   PyObject * obj1 = 0 ;
   33779             :   int result;
   33780             :   
   33781           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setRotation",&obj0,&obj1)) SWIG_fail;
   33782           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33783           0 :   if (!SWIG_IsOK(res1)) {
   33784           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setRotation" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33785             :   }
   33786           0 :   arg1 = (struct mapObj *)(argp1);
   33787           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   33788           0 :   if (!SWIG_IsOK(ecode2)) {
   33789           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_setRotation" "', argument " "2"" of type '" "double""'");
   33790             :   } 
   33791           0 :   arg2 = (double)(val2);
   33792             :   {
   33793             :     result = (int)mapObj_setRotation(arg1,arg2); {
   33794           0 :       errorObj *ms_error = msGetErrorObj();
   33795             :       
   33796           0 :       switch(ms_error->code) {
   33797             :       case MS_NOERR:
   33798             :         break;
   33799           0 :       case MS_NOTFOUND:
   33800           0 :         msResetErrorList();
   33801           0 :         break;
   33802             :       case -1:
   33803             :         break;
   33804           0 :       case MS_IOERR:
   33805           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33806           0 :           _raise_ms_exception();
   33807           0 :           msResetErrorList();
   33808           0 :           return NULL;
   33809             :         }
   33810             :       default:
   33811           0 :         _raise_ms_exception();
   33812           0 :         msResetErrorList();
   33813           0 :         return NULL;
   33814             :       }
   33815             :       
   33816             :     }
   33817             :   }
   33818             :   resultobj = SWIG_From_int((int)(result));
   33819           0 :   return resultobj;
   33820           0 : fail:
   33821             :   return NULL;
   33822             : }
   33823             : 
   33824             : 
   33825           1 : SWIGINTERN PyObject *_wrap_mapObj_getLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33826             :   PyObject *resultobj = 0;
   33827             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33828             :   int arg2 ;
   33829           1 :   void *argp1 = 0 ;
   33830             :   int res1 = 0 ;
   33831             :   int val2 ;
   33832             :   int ecode2 = 0 ;
   33833           1 :   PyObject * obj0 = 0 ;
   33834           1 :   PyObject * obj1 = 0 ;
   33835             :   layerObj *result = 0 ;
   33836             :   
   33837           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getLayer",&obj0,&obj1)) SWIG_fail;
   33838           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33839           1 :   if (!SWIG_IsOK(res1)) {
   33840           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayer" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33841             :   }
   33842           1 :   arg1 = (struct mapObj *)(argp1);
   33843           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   33844           1 :   if (!SWIG_IsOK(ecode2)) {
   33845           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_getLayer" "', argument " "2"" of type '" "int""'");
   33846             :   } 
   33847             :   arg2 = (int)(val2);
   33848             :   {
   33849           1 :     result = (layerObj *)mapObj_getLayer(arg1,arg2); {
   33850           1 :       errorObj *ms_error = msGetErrorObj();
   33851             :       
   33852           1 :       switch(ms_error->code) {
   33853             :       case MS_NOERR:
   33854             :         break;
   33855           0 :       case MS_NOTFOUND:
   33856           0 :         msResetErrorList();
   33857           0 :         break;
   33858             :       case -1:
   33859             :         break;
   33860           0 :       case MS_IOERR:
   33861           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33862           0 :           _raise_ms_exception();
   33863           0 :           msResetErrorList();
   33864           0 :           return NULL;
   33865             :         }
   33866             :       default:
   33867           0 :         _raise_ms_exception();
   33868           0 :         msResetErrorList();
   33869           0 :         return NULL;
   33870             :       }
   33871             :       
   33872             :     }
   33873             :   }
   33874           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN |  0 );
   33875           1 :   return resultobj;
   33876           0 : fail:
   33877             :   return NULL;
   33878             : }
   33879             : 
   33880             : 
   33881           1 : SWIGINTERN PyObject *_wrap_mapObj_getLayerByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33882             :   PyObject *resultobj = 0;
   33883             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33884             :   char *arg2 = (char *) 0 ;
   33885           1 :   void *argp1 = 0 ;
   33886             :   int res1 = 0 ;
   33887             :   int res2 ;
   33888           1 :   char *buf2 = 0 ;
   33889           1 :   int alloc2 = 0 ;
   33890           1 :   PyObject * obj0 = 0 ;
   33891           1 :   PyObject * obj1 = 0 ;
   33892             :   layerObj *result = 0 ;
   33893             :   
   33894           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getLayerByName",&obj0,&obj1)) SWIG_fail;
   33895           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33896           1 :   if (!SWIG_IsOK(res1)) {
   33897           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayerByName" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33898             :   }
   33899           1 :   arg1 = (struct mapObj *)(argp1);
   33900           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   33901           1 :   if (!SWIG_IsOK(res2)) {
   33902           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getLayerByName" "', argument " "2"" of type '" "char *""'");
   33903             :   }
   33904           1 :   arg2 = (char *)(buf2);
   33905             :   {
   33906           1 :     result = (layerObj *)mapObj_getLayerByName(arg1,arg2); {
   33907           1 :       errorObj *ms_error = msGetErrorObj();
   33908             :       
   33909           1 :       switch(ms_error->code) {
   33910             :       case MS_NOERR:
   33911             :         break;
   33912           0 :       case MS_NOTFOUND:
   33913           0 :         msResetErrorList();
   33914           0 :         break;
   33915             :       case -1:
   33916             :         break;
   33917           0 :       case MS_IOERR:
   33918           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33919           0 :           _raise_ms_exception();
   33920           0 :           msResetErrorList();
   33921           0 :           return NULL;
   33922             :         }
   33923             :       default:
   33924           0 :         _raise_ms_exception();
   33925           0 :         msResetErrorList();
   33926           0 :         return NULL;
   33927             :       }
   33928             :       
   33929             :     }
   33930             :   }
   33931           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN |  0 );
   33932           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   33933             :   return resultobj;
   33934           0 : fail:
   33935           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   33936             :   return NULL;
   33937             : }
   33938             : 
   33939             : 
   33940           0 : SWIGINTERN PyObject *_wrap_mapObj_getSymbolByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   33941             :   PyObject *resultobj = 0;
   33942             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   33943             :   char *arg2 = (char *) 0 ;
   33944           0 :   void *argp1 = 0 ;
   33945             :   int res1 = 0 ;
   33946             :   int res2 ;
   33947           0 :   char *buf2 = 0 ;
   33948           0 :   int alloc2 = 0 ;
   33949           0 :   PyObject * obj0 = 0 ;
   33950           0 :   PyObject * obj1 = 0 ;
   33951             :   int result;
   33952             :   
   33953           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getSymbolByName",&obj0,&obj1)) SWIG_fail;
   33954           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   33955           0 :   if (!SWIG_IsOK(res1)) {
   33956           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getSymbolByName" "', argument " "1"" of type '" "struct mapObj *""'"); 
   33957             :   }
   33958           0 :   arg1 = (struct mapObj *)(argp1);
   33959           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   33960           0 :   if (!SWIG_IsOK(res2)) {
   33961           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getSymbolByName" "', argument " "2"" of type '" "char *""'");
   33962             :   }
   33963           0 :   arg2 = (char *)(buf2);
   33964             :   {
   33965             :     result = (int)mapObj_getSymbolByName(arg1,arg2); {
   33966           0 :       errorObj *ms_error = msGetErrorObj();
   33967             :       
   33968           0 :       switch(ms_error->code) {
   33969             :       case MS_NOERR:
   33970             :         break;
   33971           0 :       case MS_NOTFOUND:
   33972           0 :         msResetErrorList();
   33973           0 :         break;
   33974             :       case -1:
   33975             :         break;
   33976           0 :       case MS_IOERR:
   33977           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   33978           0 :           _raise_ms_exception();
   33979           0 :           msResetErrorList();
   33980           0 :           return NULL;
   33981             :         }
   33982             :       default:
   33983           0 :         _raise_ms_exception();
   33984           0 :         msResetErrorList();
   33985           0 :         return NULL;
   33986             :       }
   33987             :       
   33988             :     }
   33989             :   }
   33990             :   resultobj = SWIG_From_int((int)(result));
   33991           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   33992             :   return resultobj;
   33993           0 : fail:
   33994           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   33995             :   return NULL;
   33996             : }
   33997             : 
   33998             : 
   33999           0 : SWIGINTERN PyObject *_wrap_mapObj_prepareQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34000             :   PyObject *resultobj = 0;
   34001             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34002           0 :   void *argp1 = 0 ;
   34003             :   int res1 = 0 ;
   34004           0 :   PyObject * obj0 = 0 ;
   34005             :   
   34006           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_prepareQuery",&obj0)) SWIG_fail;
   34007           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34008           0 :   if (!SWIG_IsOK(res1)) {
   34009           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_prepareQuery" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34010             :   }
   34011           0 :   arg1 = (struct mapObj *)(argp1);
   34012             :   {
   34013           0 :     mapObj_prepareQuery(arg1); {
   34014           0 :       errorObj *ms_error = msGetErrorObj();
   34015             :       
   34016           0 :       switch(ms_error->code) {
   34017             :       case MS_NOERR:
   34018             :         break;
   34019           0 :       case MS_NOTFOUND:
   34020           0 :         msResetErrorList();
   34021           0 :         break;
   34022             :       case -1:
   34023             :         break;
   34024           0 :       case MS_IOERR:
   34025           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34026           0 :           _raise_ms_exception();
   34027           0 :           msResetErrorList();
   34028           0 :           return NULL;
   34029             :         }
   34030             :       default:
   34031           0 :         _raise_ms_exception();
   34032           0 :         msResetErrorList();
   34033           0 :         return NULL;
   34034             :       }
   34035             :       
   34036             :     }
   34037             :   }
   34038             :   resultobj = SWIG_Py_Void();
   34039           0 :   return resultobj;
   34040           0 : fail:
   34041             :   return NULL;
   34042             : }
   34043             : 
   34044             : 
   34045           1 : SWIGINTERN PyObject *_wrap_mapObj_prepareImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34046             :   PyObject *resultobj = 0;
   34047             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34048           1 :   void *argp1 = 0 ;
   34049             :   int res1 = 0 ;
   34050           1 :   PyObject * obj0 = 0 ;
   34051             :   imageObj *result = 0 ;
   34052             :   
   34053           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_prepareImage",&obj0)) SWIG_fail;
   34054           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34055           1 :   if (!SWIG_IsOK(res1)) {
   34056           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_prepareImage" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34057             :   }
   34058           1 :   arg1 = (struct mapObj *)(argp1);
   34059             :   {
   34060             :     result = (imageObj *)mapObj_prepareImage(arg1); {
   34061           1 :       errorObj *ms_error = msGetErrorObj();
   34062             :       
   34063           1 :       switch(ms_error->code) {
   34064             :       case MS_NOERR:
   34065             :         break;
   34066           0 :       case MS_NOTFOUND:
   34067           0 :         msResetErrorList();
   34068           0 :         break;
   34069             :       case -1:
   34070             :         break;
   34071           0 :       case MS_IOERR:
   34072           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34073           0 :           _raise_ms_exception();
   34074           0 :           msResetErrorList();
   34075           0 :           return NULL;
   34076             :         }
   34077             :       default:
   34078           0 :         _raise_ms_exception();
   34079           0 :         msResetErrorList();
   34080           0 :         return NULL;
   34081             :       }
   34082             :       
   34083             :     }
   34084             :   }
   34085           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   34086           1 :   return resultobj;
   34087           0 : fail:
   34088             :   return NULL;
   34089             : }
   34090             : 
   34091             : 
   34092           1 : SWIGINTERN PyObject *_wrap_mapObj_setImageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34093             :   PyObject *resultobj = 0;
   34094             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34095             :   char *arg2 = (char *) 0 ;
   34096           1 :   void *argp1 = 0 ;
   34097             :   int res1 = 0 ;
   34098             :   int res2 ;
   34099           1 :   char *buf2 = 0 ;
   34100           1 :   int alloc2 = 0 ;
   34101           1 :   PyObject * obj0 = 0 ;
   34102           1 :   PyObject * obj1 = 0 ;
   34103             :   
   34104           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setImageType",&obj0,&obj1)) SWIG_fail;
   34105           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34106           1 :   if (!SWIG_IsOK(res1)) {
   34107           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setImageType" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34108             :   }
   34109           1 :   arg1 = (struct mapObj *)(argp1);
   34110           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   34111           1 :   if (!SWIG_IsOK(res2)) {
   34112           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setImageType" "', argument " "2"" of type '" "char *""'");
   34113             :   }
   34114           1 :   arg2 = (char *)(buf2);
   34115             :   {
   34116           1 :     mapObj_setImageType(arg1,arg2); {
   34117           1 :       errorObj *ms_error = msGetErrorObj();
   34118             :       
   34119           1 :       switch(ms_error->code) {
   34120             :       case MS_NOERR:
   34121             :         break;
   34122           0 :       case MS_NOTFOUND:
   34123           0 :         msResetErrorList();
   34124           0 :         break;
   34125             :       case -1:
   34126             :         break;
   34127           0 :       case MS_IOERR:
   34128           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34129           0 :           _raise_ms_exception();
   34130           0 :           msResetErrorList();
   34131           0 :           return NULL;
   34132             :         }
   34133             :       default:
   34134           0 :         _raise_ms_exception();
   34135           0 :         msResetErrorList();
   34136           0 :         return NULL;
   34137             :       }
   34138             :       
   34139             :     }
   34140             :   }
   34141             :   resultobj = SWIG_Py_Void();
   34142           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   34143             :   return resultobj;
   34144           0 : fail:
   34145           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   34146             :   return NULL;
   34147             : }
   34148             : 
   34149             : 
   34150           1 : SWIGINTERN PyObject *_wrap_mapObj_selectOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34151             :   PyObject *resultobj = 0;
   34152             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34153             :   char *arg2 = (char *) 0 ;
   34154           1 :   void *argp1 = 0 ;
   34155             :   int res1 = 0 ;
   34156             :   int res2 ;
   34157           1 :   char *buf2 = 0 ;
   34158           1 :   int alloc2 = 0 ;
   34159           1 :   PyObject * obj0 = 0 ;
   34160           1 :   PyObject * obj1 = 0 ;
   34161             :   
   34162           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_selectOutputFormat",&obj0,&obj1)) SWIG_fail;
   34163           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34164           1 :   if (!SWIG_IsOK(res1)) {
   34165           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_selectOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34166             :   }
   34167           1 :   arg1 = (struct mapObj *)(argp1);
   34168           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   34169           1 :   if (!SWIG_IsOK(res2)) {
   34170           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_selectOutputFormat" "', argument " "2"" of type '" "char *""'");
   34171             :   }
   34172           1 :   arg2 = (char *)(buf2);
   34173             :   {
   34174           1 :     mapObj_selectOutputFormat(arg1,arg2); {
   34175           1 :       errorObj *ms_error = msGetErrorObj();
   34176             :       
   34177           1 :       switch(ms_error->code) {
   34178             :       case MS_NOERR:
   34179             :         break;
   34180           0 :       case MS_NOTFOUND:
   34181           0 :         msResetErrorList();
   34182           0 :         break;
   34183             :       case -1:
   34184             :         break;
   34185           0 :       case MS_IOERR:
   34186           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34187           0 :           _raise_ms_exception();
   34188           0 :           msResetErrorList();
   34189           0 :           return NULL;
   34190             :         }
   34191             :       default:
   34192           1 :         _raise_ms_exception();
   34193           1 :         msResetErrorList();
   34194           1 :         return NULL;
   34195             :       }
   34196             :       
   34197             :     }
   34198             :   }
   34199             :   resultobj = SWIG_Py_Void();
   34200           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   34201             :   return resultobj;
   34202           0 : fail:
   34203           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   34204             :   return NULL;
   34205             : }
   34206             : 
   34207             : 
   34208           0 : SWIGINTERN PyObject *_wrap_mapObj_getOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34209             :   PyObject *resultobj = 0;
   34210             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34211             :   int arg2 ;
   34212           0 :   void *argp1 = 0 ;
   34213             :   int res1 = 0 ;
   34214             :   int val2 ;
   34215             :   int ecode2 = 0 ;
   34216           0 :   PyObject * obj0 = 0 ;
   34217           0 :   PyObject * obj1 = 0 ;
   34218             :   outputFormatObj *result = 0 ;
   34219             :   
   34220           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getOutputFormat",&obj0,&obj1)) SWIG_fail;
   34221           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34222           0 :   if (!SWIG_IsOK(res1)) {
   34223           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34224             :   }
   34225           0 :   arg1 = (struct mapObj *)(argp1);
   34226           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   34227           0 :   if (!SWIG_IsOK(ecode2)) {
   34228           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_getOutputFormat" "', argument " "2"" of type '" "int""'");
   34229             :   } 
   34230             :   arg2 = (int)(val2);
   34231             :   {
   34232           0 :     result = (outputFormatObj *)mapObj_getOutputFormat(arg1,arg2); {
   34233           0 :       errorObj *ms_error = msGetErrorObj();
   34234             :       
   34235           0 :       switch(ms_error->code) {
   34236             :       case MS_NOERR:
   34237             :         break;
   34238           0 :       case MS_NOTFOUND:
   34239           0 :         msResetErrorList();
   34240           0 :         break;
   34241             :       case -1:
   34242             :         break;
   34243           0 :       case MS_IOERR:
   34244           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34245           0 :           _raise_ms_exception();
   34246           0 :           msResetErrorList();
   34247           0 :           return NULL;
   34248             :         }
   34249             :       default:
   34250           0 :         _raise_ms_exception();
   34251           0 :         msResetErrorList();
   34252           0 :         return NULL;
   34253             :       }
   34254             :       
   34255             :     }
   34256             :   }
   34257           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, SWIG_POINTER_OWN |  0 );
   34258           0 :   return resultobj;
   34259           0 : fail:
   34260             :   return NULL;
   34261             : }
   34262             : 
   34263             : 
   34264           0 : SWIGINTERN PyObject *_wrap_mapObj_setOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34265             :   PyObject *resultobj = 0;
   34266             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34267             :   outputFormatObj *arg2 = (outputFormatObj *) 0 ;
   34268           0 :   void *argp1 = 0 ;
   34269             :   int res1 = 0 ;
   34270           0 :   void *argp2 = 0 ;
   34271             :   int res2 = 0 ;
   34272           0 :   PyObject * obj0 = 0 ;
   34273           0 :   PyObject * obj1 = 0 ;
   34274             :   
   34275           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setOutputFormat",&obj0,&obj1)) SWIG_fail;
   34276           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34277           0 :   if (!SWIG_IsOK(res1)) {
   34278           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34279             :   }
   34280           0 :   arg1 = (struct mapObj *)(argp1);
   34281           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_outputFormatObj, 0 |  0 );
   34282           0 :   if (!SWIG_IsOK(res2)) {
   34283           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setOutputFormat" "', argument " "2"" of type '" "outputFormatObj *""'"); 
   34284             :   }
   34285           0 :   arg2 = (outputFormatObj *)(argp2);
   34286             :   {
   34287             :     mapObj_setOutputFormat(arg1,arg2); {
   34288           0 :       errorObj *ms_error = msGetErrorObj();
   34289             :       
   34290           0 :       switch(ms_error->code) {
   34291             :       case MS_NOERR:
   34292             :         break;
   34293           0 :       case MS_NOTFOUND:
   34294           0 :         msResetErrorList();
   34295           0 :         break;
   34296             :       case -1:
   34297             :         break;
   34298           0 :       case MS_IOERR:
   34299           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34300           0 :           _raise_ms_exception();
   34301           0 :           msResetErrorList();
   34302           0 :           return NULL;
   34303             :         }
   34304             :       default:
   34305           0 :         _raise_ms_exception();
   34306           0 :         msResetErrorList();
   34307           0 :         return NULL;
   34308             :       }
   34309             :       
   34310             :     }
   34311             :   }
   34312             :   resultobj = SWIG_Py_Void();
   34313           0 :   return resultobj;
   34314           0 : fail:
   34315             :   return NULL;
   34316             : }
   34317             : 
   34318             : 
   34319           1 : SWIGINTERN PyObject *_wrap_mapObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34320             :   PyObject *resultobj = 0;
   34321             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34322           1 :   void *argp1 = 0 ;
   34323             :   int res1 = 0 ;
   34324           1 :   PyObject * obj0 = 0 ;
   34325             :   imageObj *result = 0 ;
   34326             :   
   34327           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_draw",&obj0)) SWIG_fail;
   34328           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34329           1 :   if (!SWIG_IsOK(res1)) {
   34330           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_draw" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34331             :   }
   34332           1 :   arg1 = (struct mapObj *)(argp1);
   34333             :   {
   34334             :     result = (imageObj *)mapObj_draw(arg1); {
   34335           1 :       errorObj *ms_error = msGetErrorObj();
   34336             :       
   34337           1 :       switch(ms_error->code) {
   34338             :       case MS_NOERR:
   34339             :         break;
   34340           0 :       case MS_NOTFOUND:
   34341           0 :         msResetErrorList();
   34342           0 :         break;
   34343             :       case -1:
   34344             :         break;
   34345           0 :       case MS_IOERR:
   34346           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34347           0 :           _raise_ms_exception();
   34348           0 :           msResetErrorList();
   34349           0 :           return NULL;
   34350             :         }
   34351             :       default:
   34352           1 :         _raise_ms_exception();
   34353           1 :         msResetErrorList();
   34354           1 :         return NULL;
   34355             :       }
   34356             :       
   34357             :     }
   34358             :   }
   34359           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   34360           1 :   return resultobj;
   34361           0 : fail:
   34362             :   return NULL;
   34363             : }
   34364             : 
   34365             : 
   34366           0 : SWIGINTERN PyObject *_wrap_mapObj_drawQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34367             :   PyObject *resultobj = 0;
   34368             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34369           0 :   void *argp1 = 0 ;
   34370             :   int res1 = 0 ;
   34371           0 :   PyObject * obj0 = 0 ;
   34372             :   imageObj *result = 0 ;
   34373             :   
   34374           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_drawQuery",&obj0)) SWIG_fail;
   34375           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34376           0 :   if (!SWIG_IsOK(res1)) {
   34377           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawQuery" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34378             :   }
   34379           0 :   arg1 = (struct mapObj *)(argp1);
   34380             :   {
   34381             :     result = (imageObj *)mapObj_drawQuery(arg1); {
   34382           0 :       errorObj *ms_error = msGetErrorObj();
   34383             :       
   34384           0 :       switch(ms_error->code) {
   34385             :       case MS_NOERR:
   34386             :         break;
   34387           0 :       case MS_NOTFOUND:
   34388           0 :         msResetErrorList();
   34389           0 :         break;
   34390             :       case -1:
   34391             :         break;
   34392           0 :       case MS_IOERR:
   34393           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34394           0 :           _raise_ms_exception();
   34395           0 :           msResetErrorList();
   34396           0 :           return NULL;
   34397             :         }
   34398             :       default:
   34399           0 :         _raise_ms_exception();
   34400           0 :         msResetErrorList();
   34401           0 :         return NULL;
   34402             :       }
   34403             :       
   34404             :     }
   34405             :   }
   34406           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   34407           0 :   return resultobj;
   34408           0 : fail:
   34409             :   return NULL;
   34410             : }
   34411             : 
   34412             : 
   34413           0 : SWIGINTERN PyObject *_wrap_mapObj_drawLegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34414             :   PyObject *resultobj = 0;
   34415             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34416             :   int arg2 = (int) 0 ;
   34417           0 :   void *argp1 = 0 ;
   34418             :   int res1 = 0 ;
   34419             :   int val2 ;
   34420             :   int ecode2 = 0 ;
   34421           0 :   PyObject * obj0 = 0 ;
   34422           0 :   PyObject * obj1 = 0 ;
   34423             :   imageObj *result = 0 ;
   34424             :   
   34425           0 :   if (!PyArg_ParseTuple(args,(char *)"O|O:mapObj_drawLegend",&obj0,&obj1)) SWIG_fail;
   34426           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34427           0 :   if (!SWIG_IsOK(res1)) {
   34428           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawLegend" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34429             :   }
   34430           0 :   arg1 = (struct mapObj *)(argp1);
   34431           0 :   if (obj1) {
   34432             :     ecode2 = SWIG_AsVal_int(obj1, &val2);
   34433           0 :     if (!SWIG_IsOK(ecode2)) {
   34434           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_drawLegend" "', argument " "2"" of type '" "int""'");
   34435             :     } 
   34436             :     arg2 = (int)(val2);
   34437             :   }
   34438             :   {
   34439             :     result = (imageObj *)mapObj_drawLegend(arg1,arg2); {
   34440           0 :       errorObj *ms_error = msGetErrorObj();
   34441             :       
   34442           0 :       switch(ms_error->code) {
   34443             :       case MS_NOERR:
   34444             :         break;
   34445           0 :       case MS_NOTFOUND:
   34446           0 :         msResetErrorList();
   34447           0 :         break;
   34448             :       case -1:
   34449             :         break;
   34450           0 :       case MS_IOERR:
   34451           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34452           0 :           _raise_ms_exception();
   34453           0 :           msResetErrorList();
   34454           0 :           return NULL;
   34455             :         }
   34456             :       default:
   34457           0 :         _raise_ms_exception();
   34458           0 :         msResetErrorList();
   34459           0 :         return NULL;
   34460             :       }
   34461             :       
   34462             :     }
   34463             :   }
   34464           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   34465           0 :   return resultobj;
   34466           0 : fail:
   34467             :   return NULL;
   34468             : }
   34469             : 
   34470             : 
   34471           0 : SWIGINTERN PyObject *_wrap_mapObj_drawScalebar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34472             :   PyObject *resultobj = 0;
   34473             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34474           0 :   void *argp1 = 0 ;
   34475             :   int res1 = 0 ;
   34476           0 :   PyObject * obj0 = 0 ;
   34477             :   imageObj *result = 0 ;
   34478             :   
   34479           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_drawScalebar",&obj0)) SWIG_fail;
   34480           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34481           0 :   if (!SWIG_IsOK(res1)) {
   34482           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawScalebar" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34483             :   }
   34484           0 :   arg1 = (struct mapObj *)(argp1);
   34485             :   {
   34486             :     result = (imageObj *)mapObj_drawScalebar(arg1); {
   34487           0 :       errorObj *ms_error = msGetErrorObj();
   34488             :       
   34489           0 :       switch(ms_error->code) {
   34490             :       case MS_NOERR:
   34491             :         break;
   34492           0 :       case MS_NOTFOUND:
   34493           0 :         msResetErrorList();
   34494           0 :         break;
   34495             :       case -1:
   34496             :         break;
   34497           0 :       case MS_IOERR:
   34498           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34499           0 :           _raise_ms_exception();
   34500           0 :           msResetErrorList();
   34501           0 :           return NULL;
   34502             :         }
   34503             :       default:
   34504           0 :         _raise_ms_exception();
   34505           0 :         msResetErrorList();
   34506           0 :         return NULL;
   34507             :       }
   34508             :       
   34509             :     }
   34510             :   }
   34511           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   34512           0 :   return resultobj;
   34513           0 : fail:
   34514             :   return NULL;
   34515             : }
   34516             : 
   34517             : 
   34518           0 : SWIGINTERN PyObject *_wrap_mapObj_drawReferenceMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34519             :   PyObject *resultobj = 0;
   34520             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34521           0 :   void *argp1 = 0 ;
   34522             :   int res1 = 0 ;
   34523           0 :   PyObject * obj0 = 0 ;
   34524             :   imageObj *result = 0 ;
   34525             :   
   34526           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_drawReferenceMap",&obj0)) SWIG_fail;
   34527           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34528           0 :   if (!SWIG_IsOK(res1)) {
   34529           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawReferenceMap" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34530             :   }
   34531           0 :   arg1 = (struct mapObj *)(argp1);
   34532             :   {
   34533             :     result = (imageObj *)mapObj_drawReferenceMap(arg1); {
   34534           0 :       errorObj *ms_error = msGetErrorObj();
   34535             :       
   34536           0 :       switch(ms_error->code) {
   34537             :       case MS_NOERR:
   34538             :         break;
   34539           0 :       case MS_NOTFOUND:
   34540           0 :         msResetErrorList();
   34541           0 :         break;
   34542             :       case -1:
   34543             :         break;
   34544           0 :       case MS_IOERR:
   34545           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34546           0 :           _raise_ms_exception();
   34547           0 :           msResetErrorList();
   34548           0 :           return NULL;
   34549             :         }
   34550             :       default:
   34551           0 :         _raise_ms_exception();
   34552           0 :         msResetErrorList();
   34553           0 :         return NULL;
   34554             :       }
   34555             :       
   34556             :     }
   34557             :   }
   34558           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   34559           0 :   return resultobj;
   34560           0 : fail:
   34561             :   return NULL;
   34562             : }
   34563             : 
   34564             : 
   34565           0 : SWIGINTERN PyObject *_wrap_mapObj_embedScalebar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34566             :   PyObject *resultobj = 0;
   34567             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34568             :   imageObj *arg2 = (imageObj *) 0 ;
   34569           0 :   void *argp1 = 0 ;
   34570             :   int res1 = 0 ;
   34571           0 :   void *argp2 = 0 ;
   34572             :   int res2 = 0 ;
   34573           0 :   PyObject * obj0 = 0 ;
   34574           0 :   PyObject * obj1 = 0 ;
   34575             :   int result;
   34576             :   
   34577           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_embedScalebar",&obj0,&obj1)) SWIG_fail;
   34578           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34579           0 :   if (!SWIG_IsOK(res1)) {
   34580           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_embedScalebar" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34581             :   }
   34582           0 :   arg1 = (struct mapObj *)(argp1);
   34583           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 |  0 );
   34584           0 :   if (!SWIG_IsOK(res2)) {
   34585           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_embedScalebar" "', argument " "2"" of type '" "imageObj *""'"); 
   34586             :   }
   34587           0 :   arg2 = (imageObj *)(argp2);
   34588             :   {
   34589             :     result = (int)mapObj_embedScalebar(arg1,arg2); {
   34590           0 :       errorObj *ms_error = msGetErrorObj();
   34591             :       
   34592           0 :       switch(ms_error->code) {
   34593             :       case MS_NOERR:
   34594             :         break;
   34595           0 :       case MS_NOTFOUND:
   34596           0 :         msResetErrorList();
   34597           0 :         break;
   34598             :       case -1:
   34599             :         break;
   34600           0 :       case MS_IOERR:
   34601           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34602           0 :           _raise_ms_exception();
   34603           0 :           msResetErrorList();
   34604           0 :           return NULL;
   34605             :         }
   34606             :       default:
   34607           0 :         _raise_ms_exception();
   34608           0 :         msResetErrorList();
   34609           0 :         return NULL;
   34610             :       }
   34611             :       
   34612             :     }
   34613             :   }
   34614             :   resultobj = SWIG_From_int((int)(result));
   34615           0 :   return resultobj;
   34616           0 : fail:
   34617             :   return NULL;
   34618             : }
   34619             : 
   34620             : 
   34621           0 : SWIGINTERN PyObject *_wrap_mapObj_embedLegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34622             :   PyObject *resultobj = 0;
   34623             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34624             :   imageObj *arg2 = (imageObj *) 0 ;
   34625           0 :   void *argp1 = 0 ;
   34626             :   int res1 = 0 ;
   34627           0 :   void *argp2 = 0 ;
   34628             :   int res2 = 0 ;
   34629           0 :   PyObject * obj0 = 0 ;
   34630           0 :   PyObject * obj1 = 0 ;
   34631             :   int result;
   34632             :   
   34633           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_embedLegend",&obj0,&obj1)) SWIG_fail;
   34634           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34635           0 :   if (!SWIG_IsOK(res1)) {
   34636           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_embedLegend" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34637             :   }
   34638           0 :   arg1 = (struct mapObj *)(argp1);
   34639           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 |  0 );
   34640           0 :   if (!SWIG_IsOK(res2)) {
   34641           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_embedLegend" "', argument " "2"" of type '" "imageObj *""'"); 
   34642             :   }
   34643           0 :   arg2 = (imageObj *)(argp2);
   34644             :   {
   34645             :     result = (int)mapObj_embedLegend(arg1,arg2); {
   34646           0 :       errorObj *ms_error = msGetErrorObj();
   34647             :       
   34648           0 :       switch(ms_error->code) {
   34649             :       case MS_NOERR:
   34650             :         break;
   34651           0 :       case MS_NOTFOUND:
   34652           0 :         msResetErrorList();
   34653           0 :         break;
   34654             :       case -1:
   34655             :         break;
   34656           0 :       case MS_IOERR:
   34657           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34658           0 :           _raise_ms_exception();
   34659           0 :           msResetErrorList();
   34660           0 :           return NULL;
   34661             :         }
   34662             :       default:
   34663           0 :         _raise_ms_exception();
   34664           0 :         msResetErrorList();
   34665           0 :         return NULL;
   34666             :       }
   34667             :       
   34668             :     }
   34669             :   }
   34670             :   resultobj = SWIG_From_int((int)(result));
   34671           0 :   return resultobj;
   34672           0 : fail:
   34673             :   return NULL;
   34674             : }
   34675             : 
   34676             : 
   34677           0 : SWIGINTERN PyObject *_wrap_mapObj_drawLabelCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34678             :   PyObject *resultobj = 0;
   34679             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34680             :   imageObj *arg2 = (imageObj *) 0 ;
   34681           0 :   void *argp1 = 0 ;
   34682             :   int res1 = 0 ;
   34683           0 :   void *argp2 = 0 ;
   34684             :   int res2 = 0 ;
   34685           0 :   PyObject * obj0 = 0 ;
   34686           0 :   PyObject * obj1 = 0 ;
   34687             :   int result;
   34688             :   
   34689           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_drawLabelCache",&obj0,&obj1)) SWIG_fail;
   34690           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34691           0 :   if (!SWIG_IsOK(res1)) {
   34692           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawLabelCache" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34693             :   }
   34694           0 :   arg1 = (struct mapObj *)(argp1);
   34695           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 |  0 );
   34696           0 :   if (!SWIG_IsOK(res2)) {
   34697           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_drawLabelCache" "', argument " "2"" of type '" "imageObj *""'"); 
   34698             :   }
   34699           0 :   arg2 = (imageObj *)(argp2);
   34700             :   {
   34701             :     result = (int)mapObj_drawLabelCache(arg1,arg2); {
   34702           0 :       errorObj *ms_error = msGetErrorObj();
   34703             :       
   34704           0 :       switch(ms_error->code) {
   34705             :       case MS_NOERR:
   34706             :         break;
   34707           0 :       case MS_NOTFOUND:
   34708           0 :         msResetErrorList();
   34709           0 :         break;
   34710             :       case -1:
   34711             :         break;
   34712           0 :       case MS_IOERR:
   34713           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34714           0 :           _raise_ms_exception();
   34715           0 :           msResetErrorList();
   34716           0 :           return NULL;
   34717             :         }
   34718             :       default:
   34719           0 :         _raise_ms_exception();
   34720           0 :         msResetErrorList();
   34721           0 :         return NULL;
   34722             :       }
   34723             :       
   34724             :     }
   34725             :   }
   34726             :   resultobj = SWIG_From_int((int)(result));
   34727           0 :   return resultobj;
   34728           0 : fail:
   34729             :   return NULL;
   34730             : }
   34731             : 
   34732             : 
   34733           0 : SWIGINTERN PyObject *_wrap_mapObj_queryByFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34734             :   PyObject *resultobj = 0;
   34735             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34736             :   char *arg2 = (char *) 0 ;
   34737           0 :   void *argp1 = 0 ;
   34738             :   int res1 = 0 ;
   34739             :   int res2 ;
   34740           0 :   char *buf2 = 0 ;
   34741           0 :   int alloc2 = 0 ;
   34742           0 :   PyObject * obj0 = 0 ;
   34743           0 :   PyObject * obj1 = 0 ;
   34744             :   int result;
   34745             :   
   34746           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByFilter",&obj0,&obj1)) SWIG_fail;
   34747           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34748           0 :   if (!SWIG_IsOK(res1)) {
   34749           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByFilter" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34750             :   }
   34751           0 :   arg1 = (struct mapObj *)(argp1);
   34752           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   34753           0 :   if (!SWIG_IsOK(res2)) {
   34754           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByFilter" "', argument " "2"" of type '" "char *""'");
   34755             :   }
   34756           0 :   arg2 = (char *)(buf2);
   34757             :   {
   34758           0 :     result = (int)mapObj_queryByFilter(arg1,arg2); {
   34759           0 :       errorObj *ms_error = msGetErrorObj();
   34760             :       
   34761           0 :       switch(ms_error->code) {
   34762             :       case MS_NOERR:
   34763             :         break;
   34764           0 :       case MS_NOTFOUND:
   34765           0 :         msResetErrorList();
   34766           0 :         break;
   34767             :       case -1:
   34768             :         break;
   34769           0 :       case MS_IOERR:
   34770           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34771           0 :           _raise_ms_exception();
   34772           0 :           msResetErrorList();
   34773           0 :           return NULL;
   34774             :         }
   34775             :       default:
   34776           0 :         _raise_ms_exception();
   34777           0 :         msResetErrorList();
   34778           0 :         return NULL;
   34779             :       }
   34780             :       
   34781             :     }
   34782             :   }
   34783             :   resultobj = SWIG_From_int((int)(result));
   34784           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   34785             :   return resultobj;
   34786           0 : fail:
   34787           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   34788             :   return NULL;
   34789             : }
   34790             : 
   34791             : 
   34792           1 : SWIGINTERN PyObject *_wrap_mapObj_queryByPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34793             :   PyObject *resultobj = 0;
   34794             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34795             :   pointObj *arg2 = (pointObj *) 0 ;
   34796             :   int arg3 ;
   34797             :   double arg4 ;
   34798           1 :   void *argp1 = 0 ;
   34799             :   int res1 = 0 ;
   34800           1 :   void *argp2 = 0 ;
   34801             :   int res2 = 0 ;
   34802             :   int val3 ;
   34803             :   int ecode3 = 0 ;
   34804             :   double val4 ;
   34805             :   int ecode4 = 0 ;
   34806           1 :   PyObject * obj0 = 0 ;
   34807           1 :   PyObject * obj1 = 0 ;
   34808           1 :   PyObject * obj2 = 0 ;
   34809           1 :   PyObject * obj3 = 0 ;
   34810             :   int result;
   34811             :   
   34812           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_queryByPoint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   34813           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34814           1 :   if (!SWIG_IsOK(res1)) {
   34815           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByPoint" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34816             :   }
   34817           1 :   arg1 = (struct mapObj *)(argp1);
   34818           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   34819           1 :   if (!SWIG_IsOK(res2)) {
   34820           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByPoint" "', argument " "2"" of type '" "pointObj *""'"); 
   34821             :   }
   34822           1 :   arg2 = (pointObj *)(argp2);
   34823           1 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   34824           1 :   if (!SWIG_IsOK(ecode3)) {
   34825           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_queryByPoint" "', argument " "3"" of type '" "int""'");
   34826             :   } 
   34827             :   arg3 = (int)(val3);
   34828           1 :   ecode4 = SWIG_AsVal_double(obj3, &val4);
   34829           1 :   if (!SWIG_IsOK(ecode4)) {
   34830           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_queryByPoint" "', argument " "4"" of type '" "double""'");
   34831             :   } 
   34832           1 :   arg4 = (double)(val4);
   34833             :   {
   34834             :     result = (int)mapObj_queryByPoint(arg1,arg2,arg3,arg4); {
   34835           1 :       errorObj *ms_error = msGetErrorObj();
   34836             :       
   34837           1 :       switch(ms_error->code) {
   34838             :       case MS_NOERR:
   34839             :         break;
   34840           0 :       case MS_NOTFOUND:
   34841           0 :         msResetErrorList();
   34842           0 :         break;
   34843             :       case -1:
   34844             :         break;
   34845           0 :       case MS_IOERR:
   34846           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34847           0 :           _raise_ms_exception();
   34848           0 :           msResetErrorList();
   34849           0 :           return NULL;
   34850             :         }
   34851             :       default:
   34852           0 :         _raise_ms_exception();
   34853           0 :         msResetErrorList();
   34854           0 :         return NULL;
   34855             :       }
   34856             :       
   34857             :     }
   34858             :   }
   34859             :   resultobj = SWIG_From_int((int)(result));
   34860           1 :   return resultobj;
   34861           0 : fail:
   34862             :   return NULL;
   34863             : }
   34864             : 
   34865             : 
   34866           0 : SWIGINTERN PyObject *_wrap_mapObj_queryByRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34867             :   PyObject *resultobj = 0;
   34868             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34869             :   rectObj arg2 ;
   34870           0 :   void *argp1 = 0 ;
   34871             :   int res1 = 0 ;
   34872             :   void *argp2 ;
   34873             :   int res2 = 0 ;
   34874           0 :   PyObject * obj0 = 0 ;
   34875           0 :   PyObject * obj1 = 0 ;
   34876             :   int result;
   34877             :   
   34878           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByRect",&obj0,&obj1)) SWIG_fail;
   34879           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34880           0 :   if (!SWIG_IsOK(res1)) {
   34881           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByRect" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34882             :   }
   34883           0 :   arg1 = (struct mapObj *)(argp1);
   34884             :   {
   34885           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_rectObj,  0 );
   34886           0 :     if (!SWIG_IsOK(res2)) {
   34887           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByRect" "', argument " "2"" of type '" "rectObj""'"); 
   34888             :     }  
   34889           0 :     if (!argp2) {
   34890             :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mapObj_queryByRect" "', argument " "2"" of type '" "rectObj""'");
   34891             :     } else {
   34892           0 :       arg2 = *((rectObj *)(argp2));
   34893             :     }
   34894             :   }
   34895             :   {
   34896             :     result = (int)mapObj_queryByRect(arg1,arg2); {
   34897           0 :       errorObj *ms_error = msGetErrorObj();
   34898             :       
   34899           0 :       switch(ms_error->code) {
   34900             :       case MS_NOERR:
   34901             :         break;
   34902           0 :       case MS_NOTFOUND:
   34903           0 :         msResetErrorList();
   34904           0 :         break;
   34905             :       case -1:
   34906             :         break;
   34907           0 :       case MS_IOERR:
   34908           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34909           0 :           _raise_ms_exception();
   34910           0 :           msResetErrorList();
   34911           0 :           return NULL;
   34912             :         }
   34913             :       default:
   34914           0 :         _raise_ms_exception();
   34915           0 :         msResetErrorList();
   34916           0 :         return NULL;
   34917             :       }
   34918             :       
   34919             :     }
   34920             :   }
   34921             :   resultobj = SWIG_From_int((int)(result));
   34922           0 :   return resultobj;
   34923           0 : fail:
   34924             :   return NULL;
   34925             : }
   34926             : 
   34927             : 
   34928           0 : SWIGINTERN PyObject *_wrap_mapObj_queryByFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34929             :   PyObject *resultobj = 0;
   34930             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34931             :   int arg2 ;
   34932           0 :   void *argp1 = 0 ;
   34933             :   int res1 = 0 ;
   34934             :   int val2 ;
   34935             :   int ecode2 = 0 ;
   34936           0 :   PyObject * obj0 = 0 ;
   34937           0 :   PyObject * obj1 = 0 ;
   34938             :   int result;
   34939             :   
   34940           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByFeatures",&obj0,&obj1)) SWIG_fail;
   34941           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34942           0 :   if (!SWIG_IsOK(res1)) {
   34943           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByFeatures" "', argument " "1"" of type '" "struct mapObj *""'"); 
   34944             :   }
   34945           0 :   arg1 = (struct mapObj *)(argp1);
   34946           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   34947           0 :   if (!SWIG_IsOK(ecode2)) {
   34948           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_queryByFeatures" "', argument " "2"" of type '" "int""'");
   34949             :   } 
   34950             :   arg2 = (int)(val2);
   34951             :   {
   34952             :     result = (int)mapObj_queryByFeatures(arg1,arg2); {
   34953           0 :       errorObj *ms_error = msGetErrorObj();
   34954             :       
   34955           0 :       switch(ms_error->code) {
   34956             :       case MS_NOERR:
   34957             :         break;
   34958           0 :       case MS_NOTFOUND:
   34959           0 :         msResetErrorList();
   34960           0 :         break;
   34961             :       case -1:
   34962             :         break;
   34963           0 :       case MS_IOERR:
   34964           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   34965           0 :           _raise_ms_exception();
   34966           0 :           msResetErrorList();
   34967           0 :           return NULL;
   34968             :         }
   34969             :       default:
   34970           0 :         _raise_ms_exception();
   34971           0 :         msResetErrorList();
   34972           0 :         return NULL;
   34973             :       }
   34974             :       
   34975             :     }
   34976             :   }
   34977             :   resultobj = SWIG_From_int((int)(result));
   34978           0 :   return resultobj;
   34979           0 : fail:
   34980             :   return NULL;
   34981             : }
   34982             : 
   34983             : 
   34984           0 : SWIGINTERN PyObject *_wrap_mapObj_queryByShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   34985             :   PyObject *resultobj = 0;
   34986             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   34987             :   shapeObj *arg2 = (shapeObj *) 0 ;
   34988           0 :   void *argp1 = 0 ;
   34989             :   int res1 = 0 ;
   34990           0 :   void *argp2 = 0 ;
   34991             :   int res2 = 0 ;
   34992           0 :   PyObject * obj0 = 0 ;
   34993           0 :   PyObject * obj1 = 0 ;
   34994             :   int result;
   34995             :   
   34996           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByShape",&obj0,&obj1)) SWIG_fail;
   34997           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   34998           0 :   if (!SWIG_IsOK(res1)) {
   34999           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByShape" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35000             :   }
   35001           0 :   arg1 = (struct mapObj *)(argp1);
   35002           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   35003           0 :   if (!SWIG_IsOK(res2)) {
   35004           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByShape" "', argument " "2"" of type '" "shapeObj *""'"); 
   35005             :   }
   35006           0 :   arg2 = (shapeObj *)(argp2);
   35007             :   {
   35008           0 :     result = (int)mapObj_queryByShape(arg1,arg2); {
   35009           0 :       errorObj *ms_error = msGetErrorObj();
   35010             :       
   35011           0 :       switch(ms_error->code) {
   35012             :       case MS_NOERR:
   35013             :         break;
   35014           0 :       case MS_NOTFOUND:
   35015           0 :         msResetErrorList();
   35016           0 :         break;
   35017             :       case -1:
   35018             :         break;
   35019           0 :       case MS_IOERR:
   35020           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35021           0 :           _raise_ms_exception();
   35022           0 :           msResetErrorList();
   35023           0 :           return NULL;
   35024             :         }
   35025             :       default:
   35026           0 :         _raise_ms_exception();
   35027           0 :         msResetErrorList();
   35028           0 :         return NULL;
   35029             :       }
   35030             :       
   35031             :     }
   35032             :   }
   35033             :   resultobj = SWIG_From_int((int)(result));
   35034           0 :   return resultobj;
   35035           0 : fail:
   35036             :   return NULL;
   35037             : }
   35038             : 
   35039             : 
   35040           1 : SWIGINTERN PyObject *_wrap_mapObj_setWKTProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35041             :   PyObject *resultobj = 0;
   35042             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35043             :   char *arg2 = (char *) 0 ;
   35044           1 :   void *argp1 = 0 ;
   35045             :   int res1 = 0 ;
   35046             :   int res2 ;
   35047           1 :   char *buf2 = 0 ;
   35048           1 :   int alloc2 = 0 ;
   35049           1 :   PyObject * obj0 = 0 ;
   35050           1 :   PyObject * obj1 = 0 ;
   35051             :   int result;
   35052             :   
   35053           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setWKTProjection",&obj0,&obj1)) SWIG_fail;
   35054           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35055           1 :   if (!SWIG_IsOK(res1)) {
   35056           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setWKTProjection" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35057             :   }
   35058           1 :   arg1 = (struct mapObj *)(argp1);
   35059           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35060           1 :   if (!SWIG_IsOK(res2)) {
   35061           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setWKTProjection" "', argument " "2"" of type '" "char *""'");
   35062             :   }
   35063           1 :   arg2 = (char *)(buf2);
   35064             :   {
   35065             :     result = (int)mapObj_setWKTProjection(arg1,arg2); {
   35066           1 :       errorObj *ms_error = msGetErrorObj();
   35067             :       
   35068           1 :       switch(ms_error->code) {
   35069             :       case MS_NOERR:
   35070             :         break;
   35071           0 :       case MS_NOTFOUND:
   35072           0 :         msResetErrorList();
   35073           0 :         break;
   35074             :       case -1:
   35075             :         break;
   35076           0 :       case MS_IOERR:
   35077           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35078           0 :           _raise_ms_exception();
   35079           0 :           msResetErrorList();
   35080           0 :           return NULL;
   35081             :         }
   35082             :       default:
   35083           0 :         _raise_ms_exception();
   35084           0 :         msResetErrorList();
   35085           0 :         return NULL;
   35086             :       }
   35087             :       
   35088             :     }
   35089             :   }
   35090             :   resultobj = SWIG_From_int((int)(result));
   35091           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35092             :   return resultobj;
   35093           0 : fail:
   35094           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35095             :   return NULL;
   35096             : }
   35097             : 
   35098             : 
   35099           1 : SWIGINTERN PyObject *_wrap_mapObj_getProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35100             :   PyObject *resultobj = 0;
   35101             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35102           1 :   void *argp1 = 0 ;
   35103             :   int res1 = 0 ;
   35104           1 :   PyObject * obj0 = 0 ;
   35105             :   char *result = 0 ;
   35106             :   
   35107           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getProjection",&obj0)) SWIG_fail;
   35108           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35109           1 :   if (!SWIG_IsOK(res1)) {
   35110           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getProjection" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35111             :   }
   35112           1 :   arg1 = (struct mapObj *)(argp1);
   35113             :   {
   35114             :     result = (char *)mapObj_getProjection(arg1); {
   35115           1 :       errorObj *ms_error = msGetErrorObj();
   35116             :       
   35117           1 :       switch(ms_error->code) {
   35118             :       case MS_NOERR:
   35119             :         break;
   35120           0 :       case MS_NOTFOUND:
   35121           0 :         msResetErrorList();
   35122           0 :         break;
   35123             :       case -1:
   35124             :         break;
   35125           0 :       case MS_IOERR:
   35126           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35127           0 :           _raise_ms_exception();
   35128           0 :           msResetErrorList();
   35129           0 :           return NULL;
   35130             :         }
   35131             :       default:
   35132           0 :         _raise_ms_exception();
   35133           0 :         msResetErrorList();
   35134           0 :         return NULL;
   35135             :       }
   35136             :       
   35137             :     }
   35138             :   }
   35139           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   35140           1 :   free((char*)result);
   35141           1 :   return resultobj;
   35142           0 : fail:
   35143             :   return NULL;
   35144             : }
   35145             : 
   35146             : 
   35147           1 : SWIGINTERN PyObject *_wrap_mapObj_setProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35148             :   PyObject *resultobj = 0;
   35149             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35150             :   char *arg2 = (char *) 0 ;
   35151           1 :   void *argp1 = 0 ;
   35152             :   int res1 = 0 ;
   35153             :   int res2 ;
   35154           1 :   char *buf2 = 0 ;
   35155           1 :   int alloc2 = 0 ;
   35156           1 :   PyObject * obj0 = 0 ;
   35157           1 :   PyObject * obj1 = 0 ;
   35158             :   int result;
   35159             :   
   35160           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setProjection",&obj0,&obj1)) SWIG_fail;
   35161           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35162           1 :   if (!SWIG_IsOK(res1)) {
   35163           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setProjection" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35164             :   }
   35165           1 :   arg1 = (struct mapObj *)(argp1);
   35166           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35167           1 :   if (!SWIG_IsOK(res2)) {
   35168           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setProjection" "', argument " "2"" of type '" "char *""'");
   35169             :   }
   35170           1 :   arg2 = (char *)(buf2);
   35171             :   {
   35172             :     result = (int)mapObj_setProjection(arg1,arg2); {
   35173           1 :       errorObj *ms_error = msGetErrorObj();
   35174             :       
   35175           1 :       switch(ms_error->code) {
   35176             :       case MS_NOERR:
   35177             :         break;
   35178           0 :       case MS_NOTFOUND:
   35179           0 :         msResetErrorList();
   35180           0 :         break;
   35181             :       case -1:
   35182             :         break;
   35183           0 :       case MS_IOERR:
   35184           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35185           0 :           _raise_ms_exception();
   35186           0 :           msResetErrorList();
   35187           0 :           return NULL;
   35188             :         }
   35189             :       default:
   35190           0 :         _raise_ms_exception();
   35191           0 :         msResetErrorList();
   35192           0 :         return NULL;
   35193             :       }
   35194             :       
   35195             :     }
   35196             :   }
   35197             :   resultobj = SWIG_From_int((int)(result));
   35198           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35199             :   return resultobj;
   35200           0 : fail:
   35201           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35202             :   return NULL;
   35203             : }
   35204             : 
   35205             : 
   35206           1 : SWIGINTERN PyObject *_wrap_mapObj_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35207             :   PyObject *resultobj = 0;
   35208             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35209             :   char *arg2 = (char *) 0 ;
   35210           1 :   void *argp1 = 0 ;
   35211             :   int res1 = 0 ;
   35212             :   int res2 ;
   35213           1 :   char *buf2 = 0 ;
   35214           1 :   int alloc2 = 0 ;
   35215           1 :   PyObject * obj0 = 0 ;
   35216           1 :   PyObject * obj1 = 0 ;
   35217             :   int result;
   35218             :   
   35219           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_save",&obj0,&obj1)) SWIG_fail;
   35220           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35221           1 :   if (!SWIG_IsOK(res1)) {
   35222           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_save" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35223             :   }
   35224           1 :   arg1 = (struct mapObj *)(argp1);
   35225           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35226           1 :   if (!SWIG_IsOK(res2)) {
   35227           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_save" "', argument " "2"" of type '" "char *""'");
   35228             :   }
   35229           1 :   arg2 = (char *)(buf2);
   35230             :   {
   35231             :     result = (int)mapObj_save(arg1,arg2); {
   35232           1 :       errorObj *ms_error = msGetErrorObj();
   35233             :       
   35234           1 :       switch(ms_error->code) {
   35235             :       case MS_NOERR:
   35236             :         break;
   35237           0 :       case MS_NOTFOUND:
   35238           0 :         msResetErrorList();
   35239           0 :         break;
   35240             :       case -1:
   35241             :         break;
   35242           0 :       case MS_IOERR:
   35243           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35244           0 :           _raise_ms_exception();
   35245           0 :           msResetErrorList();
   35246           0 :           return NULL;
   35247             :         }
   35248             :       default:
   35249           0 :         _raise_ms_exception();
   35250           0 :         msResetErrorList();
   35251           0 :         return NULL;
   35252             :       }
   35253             :       
   35254             :     }
   35255             :   }
   35256             :   resultobj = SWIG_From_int((int)(result));
   35257           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35258             :   return resultobj;
   35259           0 : fail:
   35260           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35261             :   return NULL;
   35262             : }
   35263             : 
   35264             : 
   35265           1 : SWIGINTERN PyObject *_wrap_mapObj_saveQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35266             :   PyObject *resultobj = 0;
   35267             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35268             :   char *arg2 = (char *) 0 ;
   35269             :   int arg3 = (int) 0 ;
   35270           1 :   void *argp1 = 0 ;
   35271             :   int res1 = 0 ;
   35272             :   int res2 ;
   35273           1 :   char *buf2 = 0 ;
   35274           1 :   int alloc2 = 0 ;
   35275             :   int val3 ;
   35276             :   int ecode3 = 0 ;
   35277           1 :   PyObject * obj0 = 0 ;
   35278           1 :   PyObject * obj1 = 0 ;
   35279           1 :   PyObject * obj2 = 0 ;
   35280             :   int result;
   35281             :   
   35282           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_saveQuery",&obj0,&obj1,&obj2)) SWIG_fail;
   35283           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35284           1 :   if (!SWIG_IsOK(res1)) {
   35285           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_saveQuery" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35286             :   }
   35287           1 :   arg1 = (struct mapObj *)(argp1);
   35288           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35289           1 :   if (!SWIG_IsOK(res2)) {
   35290           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_saveQuery" "', argument " "2"" of type '" "char *""'");
   35291             :   }
   35292           1 :   arg2 = (char *)(buf2);
   35293           1 :   if (obj2) {
   35294             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   35295           1 :     if (!SWIG_IsOK(ecode3)) {
   35296           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_saveQuery" "', argument " "3"" of type '" "int""'");
   35297             :     } 
   35298             :     arg3 = (int)(val3);
   35299             :   }
   35300             :   {
   35301             :     result = (int)mapObj_saveQuery(arg1,arg2,arg3); {
   35302           1 :       errorObj *ms_error = msGetErrorObj();
   35303             :       
   35304           1 :       switch(ms_error->code) {
   35305             :       case MS_NOERR:
   35306             :         break;
   35307           0 :       case MS_NOTFOUND:
   35308           0 :         msResetErrorList();
   35309           0 :         break;
   35310             :       case -1:
   35311             :         break;
   35312           0 :       case MS_IOERR:
   35313           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35314           0 :           _raise_ms_exception();
   35315           0 :           msResetErrorList();
   35316           0 :           return NULL;
   35317             :         }
   35318             :       default:
   35319           0 :         _raise_ms_exception();
   35320           0 :         msResetErrorList();
   35321           0 :         return NULL;
   35322             :       }
   35323             :       
   35324             :     }
   35325             :   }
   35326             :   resultobj = SWIG_From_int((int)(result));
   35327           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35328             :   return resultobj;
   35329           0 : fail:
   35330           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35331             :   return NULL;
   35332             : }
   35333             : 
   35334             : 
   35335           1 : SWIGINTERN PyObject *_wrap_mapObj_loadQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35336             :   PyObject *resultobj = 0;
   35337             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35338             :   char *arg2 = (char *) 0 ;
   35339           1 :   void *argp1 = 0 ;
   35340             :   int res1 = 0 ;
   35341             :   int res2 ;
   35342           1 :   char *buf2 = 0 ;
   35343           1 :   int alloc2 = 0 ;
   35344           1 :   PyObject * obj0 = 0 ;
   35345           1 :   PyObject * obj1 = 0 ;
   35346             :   int result;
   35347             :   
   35348           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_loadQuery",&obj0,&obj1)) SWIG_fail;
   35349           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35350           1 :   if (!SWIG_IsOK(res1)) {
   35351           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_loadQuery" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35352             :   }
   35353           1 :   arg1 = (struct mapObj *)(argp1);
   35354           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35355           1 :   if (!SWIG_IsOK(res2)) {
   35356           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_loadQuery" "', argument " "2"" of type '" "char *""'");
   35357             :   }
   35358           1 :   arg2 = (char *)(buf2);
   35359             :   {
   35360             :     result = (int)mapObj_loadQuery(arg1,arg2); {
   35361           1 :       errorObj *ms_error = msGetErrorObj();
   35362             :       
   35363           1 :       switch(ms_error->code) {
   35364             :       case MS_NOERR:
   35365             :         break;
   35366           0 :       case MS_NOTFOUND:
   35367           0 :         msResetErrorList();
   35368           0 :         break;
   35369             :       case -1:
   35370             :         break;
   35371           0 :       case MS_IOERR:
   35372           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35373           0 :           _raise_ms_exception();
   35374           0 :           msResetErrorList();
   35375           0 :           return NULL;
   35376             :         }
   35377             :       default:
   35378           0 :         _raise_ms_exception();
   35379           0 :         msResetErrorList();
   35380           0 :         return NULL;
   35381             :       }
   35382             :       
   35383             :     }
   35384             :   }
   35385             :   resultobj = SWIG_From_int((int)(result));
   35386           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35387             :   return resultobj;
   35388           0 : fail:
   35389           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35390             :   return NULL;
   35391             : }
   35392             : 
   35393             : 
   35394           1 : SWIGINTERN PyObject *_wrap_mapObj_freeQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35395             :   PyObject *resultobj = 0;
   35396             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35397             :   int arg2 = (int) -1 ;
   35398           1 :   void *argp1 = 0 ;
   35399             :   int res1 = 0 ;
   35400             :   int val2 ;
   35401             :   int ecode2 = 0 ;
   35402           1 :   PyObject * obj0 = 0 ;
   35403           1 :   PyObject * obj1 = 0 ;
   35404             :   
   35405           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:mapObj_freeQuery",&obj0,&obj1)) SWIG_fail;
   35406           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35407           1 :   if (!SWIG_IsOK(res1)) {
   35408           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_freeQuery" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35409             :   }
   35410           1 :   arg1 = (struct mapObj *)(argp1);
   35411           1 :   if (obj1) {
   35412             :     ecode2 = SWIG_AsVal_int(obj1, &val2);
   35413           1 :     if (!SWIG_IsOK(ecode2)) {
   35414           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_freeQuery" "', argument " "2"" of type '" "int""'");
   35415             :     } 
   35416             :     arg2 = (int)(val2);
   35417             :   }
   35418             :   {
   35419             :     mapObj_freeQuery(arg1,arg2); {
   35420           1 :       errorObj *ms_error = msGetErrorObj();
   35421             :       
   35422           1 :       switch(ms_error->code) {
   35423             :       case MS_NOERR:
   35424             :         break;
   35425           0 :       case MS_NOTFOUND:
   35426           0 :         msResetErrorList();
   35427           0 :         break;
   35428             :       case -1:
   35429             :         break;
   35430           0 :       case MS_IOERR:
   35431           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35432           0 :           _raise_ms_exception();
   35433           0 :           msResetErrorList();
   35434           0 :           return NULL;
   35435             :         }
   35436             :       default:
   35437           0 :         _raise_ms_exception();
   35438           0 :         msResetErrorList();
   35439           0 :         return NULL;
   35440             :       }
   35441             :       
   35442             :     }
   35443             :   }
   35444             :   resultobj = SWIG_Py_Void();
   35445           1 :   return resultobj;
   35446           0 : fail:
   35447             :   return NULL;
   35448             : }
   35449             : 
   35450             : 
   35451           0 : SWIGINTERN PyObject *_wrap_mapObj_saveQueryAsGML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35452             :   PyObject *resultobj = 0;
   35453             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35454             :   char *arg2 = (char *) 0 ;
   35455             :   char *arg3 = (char *) "GOMF" ;
   35456           0 :   void *argp1 = 0 ;
   35457             :   int res1 = 0 ;
   35458             :   int res2 ;
   35459           0 :   char *buf2 = 0 ;
   35460           0 :   int alloc2 = 0 ;
   35461             :   int res3 ;
   35462           0 :   char *buf3 = 0 ;
   35463           0 :   int alloc3 = 0 ;
   35464           0 :   PyObject * obj0 = 0 ;
   35465           0 :   PyObject * obj1 = 0 ;
   35466           0 :   PyObject * obj2 = 0 ;
   35467             :   int result;
   35468             :   
   35469           0 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_saveQueryAsGML",&obj0,&obj1,&obj2)) SWIG_fail;
   35470           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35471           0 :   if (!SWIG_IsOK(res1)) {
   35472           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_saveQueryAsGML" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35473             :   }
   35474           0 :   arg1 = (struct mapObj *)(argp1);
   35475           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35476           0 :   if (!SWIG_IsOK(res2)) {
   35477           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_saveQueryAsGML" "', argument " "2"" of type '" "char *""'");
   35478             :   }
   35479           0 :   arg2 = (char *)(buf2);
   35480           0 :   if (obj2) {
   35481           0 :     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   35482           0 :     if (!SWIG_IsOK(res3)) {
   35483           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_saveQueryAsGML" "', argument " "3"" of type '" "char const *""'");
   35484             :     }
   35485           0 :     arg3 = (char *)(buf3);
   35486             :   }
   35487             :   {
   35488             :     result = (int)mapObj_saveQueryAsGML(arg1,arg2,(char const *)arg3); {
   35489           0 :       errorObj *ms_error = msGetErrorObj();
   35490             :       
   35491           0 :       switch(ms_error->code) {
   35492             :       case MS_NOERR:
   35493             :         break;
   35494           0 :       case MS_NOTFOUND:
   35495           0 :         msResetErrorList();
   35496           0 :         break;
   35497             :       case -1:
   35498             :         break;
   35499           0 :       case MS_IOERR:
   35500           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35501           0 :           _raise_ms_exception();
   35502           0 :           msResetErrorList();
   35503           0 :           return NULL;
   35504             :         }
   35505             :       default:
   35506           0 :         _raise_ms_exception();
   35507           0 :         msResetErrorList();
   35508           0 :         return NULL;
   35509             :       }
   35510             :       
   35511             :     }
   35512             :   }
   35513             :   resultobj = SWIG_From_int((int)(result));
   35514           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35515           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   35516             :   return resultobj;
   35517           0 : fail:
   35518           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35519           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   35520             :   return NULL;
   35521             : }
   35522             : 
   35523             : 
   35524           1 : SWIGINTERN PyObject *_wrap_mapObj_getMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35525             :   PyObject *resultobj = 0;
   35526             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35527             :   char *arg2 = (char *) 0 ;
   35528           1 :   void *argp1 = 0 ;
   35529             :   int res1 = 0 ;
   35530             :   int res2 ;
   35531           1 :   char *buf2 = 0 ;
   35532           1 :   int alloc2 = 0 ;
   35533           1 :   PyObject * obj0 = 0 ;
   35534           1 :   PyObject * obj1 = 0 ;
   35535             :   char *result = 0 ;
   35536             :   
   35537           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getMetaData",&obj0,&obj1)) SWIG_fail;
   35538           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35539           1 :   if (!SWIG_IsOK(res1)) {
   35540           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getMetaData" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35541             :   }
   35542           1 :   arg1 = (struct mapObj *)(argp1);
   35543           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35544           1 :   if (!SWIG_IsOK(res2)) {
   35545           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getMetaData" "', argument " "2"" of type '" "char *""'");
   35546             :   }
   35547           1 :   arg2 = (char *)(buf2);
   35548             :   {
   35549           1 :     result = (char *)mapObj_getMetaData(arg1,arg2); {
   35550           1 :       errorObj *ms_error = msGetErrorObj();
   35551             :       
   35552           1 :       switch(ms_error->code) {
   35553             :       case MS_NOERR:
   35554             :         break;
   35555           0 :       case MS_NOTFOUND:
   35556           0 :         msResetErrorList();
   35557           0 :         break;
   35558             :       case -1:
   35559             :         break;
   35560           0 :       case MS_IOERR:
   35561           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35562           0 :           _raise_ms_exception();
   35563           0 :           msResetErrorList();
   35564           0 :           return NULL;
   35565             :         }
   35566             :       default:
   35567           1 :         _raise_ms_exception();
   35568           1 :         msResetErrorList();
   35569           1 :         return NULL;
   35570             :       }
   35571             :       
   35572             :     }
   35573             :   }
   35574           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   35575           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35576             :   return resultobj;
   35577           0 : fail:
   35578           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35579             :   return NULL;
   35580             : }
   35581             : 
   35582             : 
   35583           1 : SWIGINTERN PyObject *_wrap_mapObj_setMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35584             :   PyObject *resultobj = 0;
   35585             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35586             :   char *arg2 = (char *) 0 ;
   35587             :   char *arg3 = (char *) 0 ;
   35588           1 :   void *argp1 = 0 ;
   35589             :   int res1 = 0 ;
   35590             :   int res2 ;
   35591           1 :   char *buf2 = 0 ;
   35592           1 :   int alloc2 = 0 ;
   35593             :   int res3 ;
   35594           1 :   char *buf3 = 0 ;
   35595           1 :   int alloc3 = 0 ;
   35596           1 :   PyObject * obj0 = 0 ;
   35597           1 :   PyObject * obj1 = 0 ;
   35598           1 :   PyObject * obj2 = 0 ;
   35599             :   int result;
   35600             :   
   35601           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_setMetaData",&obj0,&obj1,&obj2)) SWIG_fail;
   35602           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35603           1 :   if (!SWIG_IsOK(res1)) {
   35604           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setMetaData" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35605             :   }
   35606           1 :   arg1 = (struct mapObj *)(argp1);
   35607           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35608           1 :   if (!SWIG_IsOK(res2)) {
   35609           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setMetaData" "', argument " "2"" of type '" "char *""'");
   35610             :   }
   35611           1 :   arg2 = (char *)(buf2);
   35612           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   35613           1 :   if (!SWIG_IsOK(res3)) {
   35614           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_setMetaData" "', argument " "3"" of type '" "char *""'");
   35615             :   }
   35616           1 :   arg3 = (char *)(buf3);
   35617             :   {
   35618             :     result = (int)mapObj_setMetaData(arg1,arg2,arg3); {
   35619           1 :       errorObj *ms_error = msGetErrorObj();
   35620             :       
   35621           1 :       switch(ms_error->code) {
   35622             :       case MS_NOERR:
   35623             :         break;
   35624           0 :       case MS_NOTFOUND:
   35625           0 :         msResetErrorList();
   35626           0 :         break;
   35627             :       case -1:
   35628             :         break;
   35629           0 :       case MS_IOERR:
   35630           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35631           0 :           _raise_ms_exception();
   35632           0 :           msResetErrorList();
   35633           0 :           return NULL;
   35634             :         }
   35635             :       default:
   35636           0 :         _raise_ms_exception();
   35637           0 :         msResetErrorList();
   35638           0 :         return NULL;
   35639             :       }
   35640             :       
   35641             :     }
   35642             :   }
   35643             :   resultobj = SWIG_From_int((int)(result));
   35644           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35645           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   35646             :   return resultobj;
   35647           0 : fail:
   35648           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35649           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   35650             :   return NULL;
   35651             : }
   35652             : 
   35653             : 
   35654           0 : SWIGINTERN PyObject *_wrap_mapObj_removeMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35655             :   PyObject *resultobj = 0;
   35656             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35657             :   char *arg2 = (char *) 0 ;
   35658           0 :   void *argp1 = 0 ;
   35659             :   int res1 = 0 ;
   35660             :   int res2 ;
   35661           0 :   char *buf2 = 0 ;
   35662           0 :   int alloc2 = 0 ;
   35663           0 :   PyObject * obj0 = 0 ;
   35664           0 :   PyObject * obj1 = 0 ;
   35665             :   int result;
   35666             :   
   35667           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_removeMetaData",&obj0,&obj1)) SWIG_fail;
   35668           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35669           0 :   if (!SWIG_IsOK(res1)) {
   35670           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_removeMetaData" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35671             :   }
   35672           0 :   arg1 = (struct mapObj *)(argp1);
   35673           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35674           0 :   if (!SWIG_IsOK(res2)) {
   35675           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_removeMetaData" "', argument " "2"" of type '" "char *""'");
   35676             :   }
   35677           0 :   arg2 = (char *)(buf2);
   35678             :   {
   35679             :     result = (int)mapObj_removeMetaData(arg1,arg2); {
   35680           0 :       errorObj *ms_error = msGetErrorObj();
   35681             :       
   35682           0 :       switch(ms_error->code) {
   35683             :       case MS_NOERR:
   35684             :         break;
   35685           0 :       case MS_NOTFOUND:
   35686           0 :         msResetErrorList();
   35687           0 :         break;
   35688             :       case -1:
   35689             :         break;
   35690           0 :       case MS_IOERR:
   35691           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35692           0 :           _raise_ms_exception();
   35693           0 :           msResetErrorList();
   35694           0 :           return NULL;
   35695             :         }
   35696             :       default:
   35697           0 :         _raise_ms_exception();
   35698           0 :         msResetErrorList();
   35699           0 :         return NULL;
   35700             :       }
   35701             :       
   35702             :     }
   35703             :   }
   35704             :   resultobj = SWIG_From_int((int)(result));
   35705           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35706             :   return resultobj;
   35707           0 : fail:
   35708           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35709             :   return NULL;
   35710             : }
   35711             : 
   35712             : 
   35713           1 : SWIGINTERN PyObject *_wrap_mapObj_getFirstMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35714             :   PyObject *resultobj = 0;
   35715             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35716           1 :   void *argp1 = 0 ;
   35717             :   int res1 = 0 ;
   35718           1 :   PyObject * obj0 = 0 ;
   35719             :   char *result = 0 ;
   35720             :   
   35721           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getFirstMetaDataKey",&obj0)) SWIG_fail;
   35722           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35723           1 :   if (!SWIG_IsOK(res1)) {
   35724           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getFirstMetaDataKey" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35725             :   }
   35726           1 :   arg1 = (struct mapObj *)(argp1);
   35727             :   {
   35728             :     result = (char *)mapObj_getFirstMetaDataKey(arg1); {
   35729           1 :       errorObj *ms_error = msGetErrorObj();
   35730             :       
   35731           1 :       switch(ms_error->code) {
   35732             :       case MS_NOERR:
   35733             :         break;
   35734           0 :       case MS_NOTFOUND:
   35735           0 :         msResetErrorList();
   35736           0 :         break;
   35737             :       case -1:
   35738             :         break;
   35739           0 :       case MS_IOERR:
   35740           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35741           0 :           _raise_ms_exception();
   35742           0 :           msResetErrorList();
   35743           0 :           return NULL;
   35744             :         }
   35745             :       default:
   35746           0 :         _raise_ms_exception();
   35747           0 :         msResetErrorList();
   35748           0 :         return NULL;
   35749             :       }
   35750             :       
   35751             :     }
   35752             :   }
   35753           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   35754           1 :   return resultobj;
   35755           0 : fail:
   35756             :   return NULL;
   35757             : }
   35758             : 
   35759             : 
   35760           1 : SWIGINTERN PyObject *_wrap_mapObj_getNextMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35761             :   PyObject *resultobj = 0;
   35762             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35763             :   char *arg2 = (char *) 0 ;
   35764           1 :   void *argp1 = 0 ;
   35765             :   int res1 = 0 ;
   35766             :   int res2 ;
   35767           1 :   char *buf2 = 0 ;
   35768           1 :   int alloc2 = 0 ;
   35769           1 :   PyObject * obj0 = 0 ;
   35770           1 :   PyObject * obj1 = 0 ;
   35771             :   char *result = 0 ;
   35772             :   
   35773           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getNextMetaDataKey",&obj0,&obj1)) SWIG_fail;
   35774           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35775           1 :   if (!SWIG_IsOK(res1)) {
   35776           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getNextMetaDataKey" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35777             :   }
   35778           1 :   arg1 = (struct mapObj *)(argp1);
   35779           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35780           1 :   if (!SWIG_IsOK(res2)) {
   35781           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getNextMetaDataKey" "', argument " "2"" of type '" "char *""'");
   35782             :   }
   35783           1 :   arg2 = (char *)(buf2);
   35784             :   {
   35785             :     result = (char *)mapObj_getNextMetaDataKey(arg1,arg2); {
   35786           1 :       errorObj *ms_error = msGetErrorObj();
   35787             :       
   35788           1 :       switch(ms_error->code) {
   35789             :       case MS_NOERR:
   35790             :         break;
   35791           0 :       case MS_NOTFOUND:
   35792           0 :         msResetErrorList();
   35793           0 :         break;
   35794             :       case -1:
   35795             :         break;
   35796           0 :       case MS_IOERR:
   35797           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35798           0 :           _raise_ms_exception();
   35799           0 :           msResetErrorList();
   35800           0 :           return NULL;
   35801             :         }
   35802             :       default:
   35803           0 :         _raise_ms_exception();
   35804           0 :         msResetErrorList();
   35805           0 :         return NULL;
   35806             :       }
   35807             :       
   35808             :     }
   35809             :   }
   35810           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   35811           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35812             :   return resultobj;
   35813           0 : fail:
   35814           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35815             :   return NULL;
   35816             : }
   35817             : 
   35818             : 
   35819           0 : SWIGINTERN PyObject *_wrap_mapObj_setSymbolSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35820             :   PyObject *resultobj = 0;
   35821             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35822             :   char *arg2 = (char *) 0 ;
   35823           0 :   void *argp1 = 0 ;
   35824             :   int res1 = 0 ;
   35825             :   int res2 ;
   35826           0 :   char *buf2 = 0 ;
   35827           0 :   int alloc2 = 0 ;
   35828           0 :   PyObject * obj0 = 0 ;
   35829           0 :   PyObject * obj1 = 0 ;
   35830             :   int result;
   35831             :   
   35832           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setSymbolSet",&obj0,&obj1)) SWIG_fail;
   35833           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35834           0 :   if (!SWIG_IsOK(res1)) {
   35835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setSymbolSet" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35836             :   }
   35837           0 :   arg1 = (struct mapObj *)(argp1);
   35838           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35839           0 :   if (!SWIG_IsOK(res2)) {
   35840           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setSymbolSet" "', argument " "2"" of type '" "char *""'");
   35841             :   }
   35842           0 :   arg2 = (char *)(buf2);
   35843             :   {
   35844           0 :     result = (int)mapObj_setSymbolSet(arg1,arg2); {
   35845           0 :       errorObj *ms_error = msGetErrorObj();
   35846             :       
   35847           0 :       switch(ms_error->code) {
   35848             :       case MS_NOERR:
   35849             :         break;
   35850           0 :       case MS_NOTFOUND:
   35851           0 :         msResetErrorList();
   35852           0 :         break;
   35853             :       case -1:
   35854             :         break;
   35855           0 :       case MS_IOERR:
   35856           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35857           0 :           _raise_ms_exception();
   35858           0 :           msResetErrorList();
   35859           0 :           return NULL;
   35860             :         }
   35861             :       default:
   35862           0 :         _raise_ms_exception();
   35863           0 :         msResetErrorList();
   35864           0 :         return NULL;
   35865             :       }
   35866             :       
   35867             :     }
   35868             :   }
   35869             :   resultobj = SWIG_From_int((int)(result));
   35870           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35871             :   return resultobj;
   35872           0 : fail:
   35873           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35874             :   return NULL;
   35875             : }
   35876             : 
   35877             : 
   35878           1 : SWIGINTERN PyObject *_wrap_mapObj_getNumSymbols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35879             :   PyObject *resultobj = 0;
   35880             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35881           1 :   void *argp1 = 0 ;
   35882             :   int res1 = 0 ;
   35883           1 :   PyObject * obj0 = 0 ;
   35884             :   int result;
   35885             :   
   35886           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getNumSymbols",&obj0)) SWIG_fail;
   35887           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35888           1 :   if (!SWIG_IsOK(res1)) {
   35889           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getNumSymbols" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35890             :   }
   35891           1 :   arg1 = (struct mapObj *)(argp1);
   35892             :   {
   35893           1 :     result = (int)mapObj_getNumSymbols(arg1); {
   35894           1 :       errorObj *ms_error = msGetErrorObj();
   35895             :       
   35896           1 :       switch(ms_error->code) {
   35897             :       case MS_NOERR:
   35898             :         break;
   35899           0 :       case MS_NOTFOUND:
   35900           0 :         msResetErrorList();
   35901           0 :         break;
   35902             :       case -1:
   35903             :         break;
   35904           0 :       case MS_IOERR:
   35905           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35906           0 :           _raise_ms_exception();
   35907           0 :           msResetErrorList();
   35908           0 :           return NULL;
   35909             :         }
   35910             :       default:
   35911           0 :         _raise_ms_exception();
   35912           0 :         msResetErrorList();
   35913           0 :         return NULL;
   35914             :       }
   35915             :       
   35916             :     }
   35917             :   }
   35918             :   resultobj = SWIG_From_int((int)(result));
   35919           1 :   return resultobj;
   35920           0 : fail:
   35921             :   return NULL;
   35922             : }
   35923             : 
   35924             : 
   35925           0 : SWIGINTERN PyObject *_wrap_mapObj_setFontSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35926             :   PyObject *resultobj = 0;
   35927             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35928             :   char *arg2 = (char *) 0 ;
   35929           0 :   void *argp1 = 0 ;
   35930             :   int res1 = 0 ;
   35931             :   int res2 ;
   35932           0 :   char *buf2 = 0 ;
   35933           0 :   int alloc2 = 0 ;
   35934           0 :   PyObject * obj0 = 0 ;
   35935           0 :   PyObject * obj1 = 0 ;
   35936             :   int result;
   35937             :   
   35938           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setFontSet",&obj0,&obj1)) SWIG_fail;
   35939           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35940           0 :   if (!SWIG_IsOK(res1)) {
   35941           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setFontSet" "', argument " "1"" of type '" "struct mapObj *""'"); 
   35942             :   }
   35943           0 :   arg1 = (struct mapObj *)(argp1);
   35944           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   35945           0 :   if (!SWIG_IsOK(res2)) {
   35946           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setFontSet" "', argument " "2"" of type '" "char *""'");
   35947             :   }
   35948           0 :   arg2 = (char *)(buf2);
   35949             :   {
   35950           0 :     result = (int)mapObj_setFontSet(arg1,arg2); {
   35951           0 :       errorObj *ms_error = msGetErrorObj();
   35952             :       
   35953           0 :       switch(ms_error->code) {
   35954             :       case MS_NOERR:
   35955             :         break;
   35956           0 :       case MS_NOTFOUND:
   35957           0 :         msResetErrorList();
   35958           0 :         break;
   35959             :       case -1:
   35960             :         break;
   35961           0 :       case MS_IOERR:
   35962           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   35963           0 :           _raise_ms_exception();
   35964           0 :           msResetErrorList();
   35965           0 :           return NULL;
   35966             :         }
   35967             :       default:
   35968           0 :         _raise_ms_exception();
   35969           0 :         msResetErrorList();
   35970           0 :         return NULL;
   35971             :       }
   35972             :       
   35973             :     }
   35974             :   }
   35975             :   resultobj = SWIG_From_int((int)(result));
   35976           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35977             :   return resultobj;
   35978           0 : fail:
   35979           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   35980             :   return NULL;
   35981             : }
   35982             : 
   35983             : 
   35984           0 : SWIGINTERN PyObject *_wrap_mapObj_saveMapContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   35985             :   PyObject *resultobj = 0;
   35986             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   35987             :   char *arg2 = (char *) 0 ;
   35988           0 :   void *argp1 = 0 ;
   35989             :   int res1 = 0 ;
   35990             :   int res2 ;
   35991           0 :   char *buf2 = 0 ;
   35992           0 :   int alloc2 = 0 ;
   35993           0 :   PyObject * obj0 = 0 ;
   35994           0 :   PyObject * obj1 = 0 ;
   35995             :   int result;
   35996             :   
   35997           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_saveMapContext",&obj0,&obj1)) SWIG_fail;
   35998           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   35999           0 :   if (!SWIG_IsOK(res1)) {
   36000           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_saveMapContext" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36001             :   }
   36002           0 :   arg1 = (struct mapObj *)(argp1);
   36003           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36004           0 :   if (!SWIG_IsOK(res2)) {
   36005           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_saveMapContext" "', argument " "2"" of type '" "char *""'");
   36006             :   }
   36007           0 :   arg2 = (char *)(buf2);
   36008             :   {
   36009             :     result = (int)mapObj_saveMapContext(arg1,arg2); {
   36010           0 :       errorObj *ms_error = msGetErrorObj();
   36011             :       
   36012           0 :       switch(ms_error->code) {
   36013             :       case MS_NOERR:
   36014             :         break;
   36015           0 :       case MS_NOTFOUND:
   36016           0 :         msResetErrorList();
   36017           0 :         break;
   36018             :       case -1:
   36019             :         break;
   36020           0 :       case MS_IOERR:
   36021           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36022           0 :           _raise_ms_exception();
   36023           0 :           msResetErrorList();
   36024           0 :           return NULL;
   36025             :         }
   36026             :       default:
   36027           0 :         _raise_ms_exception();
   36028           0 :         msResetErrorList();
   36029           0 :         return NULL;
   36030             :       }
   36031             :       
   36032             :     }
   36033             :   }
   36034             :   resultobj = SWIG_From_int((int)(result));
   36035           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36036             :   return resultobj;
   36037           0 : fail:
   36038           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36039             :   return NULL;
   36040             : }
   36041             : 
   36042             : 
   36043           0 : SWIGINTERN PyObject *_wrap_mapObj_loadMapContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36044             :   PyObject *resultobj = 0;
   36045             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36046             :   char *arg2 = (char *) 0 ;
   36047             :   int arg3 = (int) 0 ;
   36048           0 :   void *argp1 = 0 ;
   36049             :   int res1 = 0 ;
   36050             :   int res2 ;
   36051           0 :   char *buf2 = 0 ;
   36052           0 :   int alloc2 = 0 ;
   36053             :   int val3 ;
   36054             :   int ecode3 = 0 ;
   36055           0 :   PyObject * obj0 = 0 ;
   36056           0 :   PyObject * obj1 = 0 ;
   36057           0 :   PyObject * obj2 = 0 ;
   36058             :   int result;
   36059             :   
   36060           0 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_loadMapContext",&obj0,&obj1,&obj2)) SWIG_fail;
   36061           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36062           0 :   if (!SWIG_IsOK(res1)) {
   36063           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_loadMapContext" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36064             :   }
   36065           0 :   arg1 = (struct mapObj *)(argp1);
   36066           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36067           0 :   if (!SWIG_IsOK(res2)) {
   36068           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_loadMapContext" "', argument " "2"" of type '" "char *""'");
   36069             :   }
   36070           0 :   arg2 = (char *)(buf2);
   36071           0 :   if (obj2) {
   36072             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   36073           0 :     if (!SWIG_IsOK(ecode3)) {
   36074           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_loadMapContext" "', argument " "3"" of type '" "int""'");
   36075             :     } 
   36076             :     arg3 = (int)(val3);
   36077             :   }
   36078             :   {
   36079             :     result = (int)mapObj_loadMapContext(arg1,arg2,arg3); {
   36080           0 :       errorObj *ms_error = msGetErrorObj();
   36081             :       
   36082           0 :       switch(ms_error->code) {
   36083             :       case MS_NOERR:
   36084             :         break;
   36085           0 :       case MS_NOTFOUND:
   36086           0 :         msResetErrorList();
   36087           0 :         break;
   36088             :       case -1:
   36089             :         break;
   36090           0 :       case MS_IOERR:
   36091           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36092           0 :           _raise_ms_exception();
   36093           0 :           msResetErrorList();
   36094           0 :           return NULL;
   36095             :         }
   36096             :       default:
   36097           0 :         _raise_ms_exception();
   36098           0 :         msResetErrorList();
   36099           0 :         return NULL;
   36100             :       }
   36101             :       
   36102             :     }
   36103             :   }
   36104             :   resultobj = SWIG_From_int((int)(result));
   36105           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36106             :   return resultobj;
   36107           0 : fail:
   36108           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36109             :   return NULL;
   36110             : }
   36111             : 
   36112             : 
   36113           0 : SWIGINTERN PyObject *_wrap_mapObj_moveLayerUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36114             :   PyObject *resultobj = 0;
   36115             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36116             :   int arg2 ;
   36117           0 :   void *argp1 = 0 ;
   36118             :   int res1 = 0 ;
   36119             :   int val2 ;
   36120             :   int ecode2 = 0 ;
   36121           0 :   PyObject * obj0 = 0 ;
   36122           0 :   PyObject * obj1 = 0 ;
   36123             :   int result;
   36124             :   
   36125           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_moveLayerUp",&obj0,&obj1)) SWIG_fail;
   36126           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36127           0 :   if (!SWIG_IsOK(res1)) {
   36128           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_moveLayerUp" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36129             :   }
   36130           0 :   arg1 = (struct mapObj *)(argp1);
   36131           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   36132           0 :   if (!SWIG_IsOK(ecode2)) {
   36133           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_moveLayerUp" "', argument " "2"" of type '" "int""'");
   36134             :   } 
   36135             :   arg2 = (int)(val2);
   36136             :   {
   36137             :     result = (int)mapObj_moveLayerUp(arg1,arg2); {
   36138           0 :       errorObj *ms_error = msGetErrorObj();
   36139             :       
   36140           0 :       switch(ms_error->code) {
   36141             :       case MS_NOERR:
   36142             :         break;
   36143           0 :       case MS_NOTFOUND:
   36144           0 :         msResetErrorList();
   36145           0 :         break;
   36146             :       case -1:
   36147             :         break;
   36148           0 :       case MS_IOERR:
   36149           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36150           0 :           _raise_ms_exception();
   36151           0 :           msResetErrorList();
   36152           0 :           return NULL;
   36153             :         }
   36154             :       default:
   36155           0 :         _raise_ms_exception();
   36156           0 :         msResetErrorList();
   36157           0 :         return NULL;
   36158             :       }
   36159             :       
   36160             :     }
   36161             :   }
   36162             :   resultobj = SWIG_From_int((int)(result));
   36163           0 :   return resultobj;
   36164           0 : fail:
   36165             :   return NULL;
   36166             : }
   36167             : 
   36168             : 
   36169           0 : SWIGINTERN PyObject *_wrap_mapObj_moveLayerDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36170             :   PyObject *resultobj = 0;
   36171             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36172             :   int arg2 ;
   36173           0 :   void *argp1 = 0 ;
   36174             :   int res1 = 0 ;
   36175             :   int val2 ;
   36176             :   int ecode2 = 0 ;
   36177           0 :   PyObject * obj0 = 0 ;
   36178           0 :   PyObject * obj1 = 0 ;
   36179             :   int result;
   36180             :   
   36181           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_moveLayerDown",&obj0,&obj1)) SWIG_fail;
   36182           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36183           0 :   if (!SWIG_IsOK(res1)) {
   36184           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_moveLayerDown" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36185             :   }
   36186           0 :   arg1 = (struct mapObj *)(argp1);
   36187           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   36188           0 :   if (!SWIG_IsOK(ecode2)) {
   36189           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_moveLayerDown" "', argument " "2"" of type '" "int""'");
   36190             :   } 
   36191             :   arg2 = (int)(val2);
   36192             :   {
   36193             :     result = (int)mapObj_moveLayerDown(arg1,arg2); {
   36194           0 :       errorObj *ms_error = msGetErrorObj();
   36195             :       
   36196           0 :       switch(ms_error->code) {
   36197             :       case MS_NOERR:
   36198             :         break;
   36199           0 :       case MS_NOTFOUND:
   36200           0 :         msResetErrorList();
   36201           0 :         break;
   36202             :       case -1:
   36203             :         break;
   36204           0 :       case MS_IOERR:
   36205           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36206           0 :           _raise_ms_exception();
   36207           0 :           msResetErrorList();
   36208           0 :           return NULL;
   36209             :         }
   36210             :       default:
   36211           0 :         _raise_ms_exception();
   36212           0 :         msResetErrorList();
   36213           0 :         return NULL;
   36214             :       }
   36215             :       
   36216             :     }
   36217             :   }
   36218             :   resultobj = SWIG_From_int((int)(result));
   36219           0 :   return resultobj;
   36220           0 : fail:
   36221             :   return NULL;
   36222             : }
   36223             : 
   36224             : 
   36225           0 : SWIGINTERN PyObject *_wrap_mapObj_getLayersDrawingOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36226             :   PyObject *resultobj = 0;
   36227             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36228           0 :   void *argp1 = 0 ;
   36229             :   int res1 = 0 ;
   36230           0 :   PyObject * obj0 = 0 ;
   36231             :   intarray *result = 0 ;
   36232             :   
   36233           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getLayersDrawingOrder",&obj0)) SWIG_fail;
   36234           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36235           0 :   if (!SWIG_IsOK(res1)) {
   36236           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayersDrawingOrder" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36237             :   }
   36238           0 :   arg1 = (struct mapObj *)(argp1);
   36239             :   {
   36240           0 :     result = (intarray *)mapObj_getLayersDrawingOrder(arg1); {
   36241           0 :       errorObj *ms_error = msGetErrorObj();
   36242             :       
   36243           0 :       switch(ms_error->code) {
   36244             :       case MS_NOERR:
   36245             :         break;
   36246           0 :       case MS_NOTFOUND:
   36247           0 :         msResetErrorList();
   36248           0 :         break;
   36249             :       case -1:
   36250             :         break;
   36251           0 :       case MS_IOERR:
   36252           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36253           0 :           _raise_ms_exception();
   36254           0 :           msResetErrorList();
   36255           0 :           return NULL;
   36256             :         }
   36257             :       default:
   36258           0 :         _raise_ms_exception();
   36259           0 :         msResetErrorList();
   36260           0 :         return NULL;
   36261             :       }
   36262             :       
   36263             :     }
   36264             :   }
   36265           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intarray, SWIG_POINTER_OWN |  0 );
   36266           0 :   return resultobj;
   36267           0 : fail:
   36268             :   return NULL;
   36269             : }
   36270             : 
   36271             : 
   36272           0 : SWIGINTERN PyObject *_wrap_mapObj_setLayersDrawingOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36273             :   PyObject *resultobj = 0;
   36274             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36275             :   int *arg2 = (int *) 0 ;
   36276           0 :   void *argp1 = 0 ;
   36277             :   int res1 = 0 ;
   36278           0 :   void *argp2 = 0 ;
   36279             :   int res2 = 0 ;
   36280           0 :   PyObject * obj0 = 0 ;
   36281           0 :   PyObject * obj1 = 0 ;
   36282             :   int result;
   36283             :   
   36284           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setLayersDrawingOrder",&obj0,&obj1)) SWIG_fail;
   36285           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36286           0 :   if (!SWIG_IsOK(res1)) {
   36287           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setLayersDrawingOrder" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36288             :   }
   36289           0 :   arg1 = (struct mapObj *)(argp1);
   36290           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
   36291           0 :   if (!SWIG_IsOK(res2)) {
   36292           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setLayersDrawingOrder" "', argument " "2"" of type '" "int *""'"); 
   36293             :   }
   36294           0 :   arg2 = (int *)(argp2);
   36295             :   {
   36296             :     result = (int)mapObj_setLayersDrawingOrder(arg1,arg2); {
   36297           0 :       errorObj *ms_error = msGetErrorObj();
   36298             :       
   36299           0 :       switch(ms_error->code) {
   36300             :       case MS_NOERR:
   36301             :         break;
   36302           0 :       case MS_NOTFOUND:
   36303           0 :         msResetErrorList();
   36304           0 :         break;
   36305             :       case -1:
   36306             :         break;
   36307           0 :       case MS_IOERR:
   36308           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36309           0 :           _raise_ms_exception();
   36310           0 :           msResetErrorList();
   36311           0 :           return NULL;
   36312             :         }
   36313             :       default:
   36314           0 :         _raise_ms_exception();
   36315           0 :         msResetErrorList();
   36316           0 :         return NULL;
   36317             :       }
   36318             :       
   36319             :     }
   36320             :   }
   36321             :   resultobj = SWIG_From_int((int)(result));
   36322           0 :   return resultobj;
   36323           0 : fail:
   36324             :   return NULL;
   36325             : }
   36326             : 
   36327             : 
   36328           0 : SWIGINTERN PyObject *_wrap_mapObj_setConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36329             :   PyObject *resultobj = 0;
   36330             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36331             :   char *arg2 = (char *) 0 ;
   36332             :   char *arg3 = (char *) 0 ;
   36333           0 :   void *argp1 = 0 ;
   36334             :   int res1 = 0 ;
   36335             :   int res2 ;
   36336           0 :   char *buf2 = 0 ;
   36337           0 :   int alloc2 = 0 ;
   36338             :   int res3 ;
   36339           0 :   char *buf3 = 0 ;
   36340           0 :   int alloc3 = 0 ;
   36341           0 :   PyObject * obj0 = 0 ;
   36342           0 :   PyObject * obj1 = 0 ;
   36343           0 :   PyObject * obj2 = 0 ;
   36344             :   
   36345           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_setConfigOption",&obj0,&obj1,&obj2)) SWIG_fail;
   36346           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36347           0 :   if (!SWIG_IsOK(res1)) {
   36348           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setConfigOption" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36349             :   }
   36350           0 :   arg1 = (struct mapObj *)(argp1);
   36351           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36352           0 :   if (!SWIG_IsOK(res2)) {
   36353           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setConfigOption" "', argument " "2"" of type '" "char *""'");
   36354             :   }
   36355           0 :   arg2 = (char *)(buf2);
   36356           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   36357           0 :   if (!SWIG_IsOK(res3)) {
   36358           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_setConfigOption" "', argument " "3"" of type '" "char *""'");
   36359             :   }
   36360           0 :   arg3 = (char *)(buf3);
   36361             :   {
   36362             :     mapObj_setConfigOption(arg1,arg2,arg3); {
   36363           0 :       errorObj *ms_error = msGetErrorObj();
   36364             :       
   36365           0 :       switch(ms_error->code) {
   36366             :       case MS_NOERR:
   36367             :         break;
   36368           0 :       case MS_NOTFOUND:
   36369           0 :         msResetErrorList();
   36370           0 :         break;
   36371             :       case -1:
   36372             :         break;
   36373           0 :       case MS_IOERR:
   36374           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36375           0 :           _raise_ms_exception();
   36376           0 :           msResetErrorList();
   36377           0 :           return NULL;
   36378             :         }
   36379             :       default:
   36380           0 :         _raise_ms_exception();
   36381           0 :         msResetErrorList();
   36382           0 :         return NULL;
   36383             :       }
   36384             :       
   36385             :     }
   36386             :   }
   36387             :   resultobj = SWIG_Py_Void();
   36388           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36389           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   36390             :   return resultobj;
   36391           0 : fail:
   36392           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36393           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   36394             :   return NULL;
   36395             : }
   36396             : 
   36397             : 
   36398           0 : SWIGINTERN PyObject *_wrap_mapObj_getConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36399             :   PyObject *resultobj = 0;
   36400             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36401             :   char *arg2 = (char *) 0 ;
   36402           0 :   void *argp1 = 0 ;
   36403             :   int res1 = 0 ;
   36404             :   int res2 ;
   36405           0 :   char *buf2 = 0 ;
   36406           0 :   int alloc2 = 0 ;
   36407           0 :   PyObject * obj0 = 0 ;
   36408           0 :   PyObject * obj1 = 0 ;
   36409             :   char *result = 0 ;
   36410             :   
   36411           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getConfigOption",&obj0,&obj1)) SWIG_fail;
   36412           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36413           0 :   if (!SWIG_IsOK(res1)) {
   36414           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getConfigOption" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36415             :   }
   36416           0 :   arg1 = (struct mapObj *)(argp1);
   36417           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36418           0 :   if (!SWIG_IsOK(res2)) {
   36419           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getConfigOption" "', argument " "2"" of type '" "char *""'");
   36420             :   }
   36421           0 :   arg2 = (char *)(buf2);
   36422             :   {
   36423             :     result = (char *)mapObj_getConfigOption(arg1,arg2); {
   36424           0 :       errorObj *ms_error = msGetErrorObj();
   36425             :       
   36426           0 :       switch(ms_error->code) {
   36427             :       case MS_NOERR:
   36428             :         break;
   36429           0 :       case MS_NOTFOUND:
   36430           0 :         msResetErrorList();
   36431           0 :         break;
   36432             :       case -1:
   36433             :         break;
   36434           0 :       case MS_IOERR:
   36435           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36436           0 :           _raise_ms_exception();
   36437           0 :           msResetErrorList();
   36438           0 :           return NULL;
   36439             :         }
   36440             :       default:
   36441           0 :         _raise_ms_exception();
   36442           0 :         msResetErrorList();
   36443           0 :         return NULL;
   36444             :       }
   36445             :       
   36446             :     }
   36447             :   }
   36448           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   36449           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36450             :   return resultobj;
   36451           0 : fail:
   36452           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36453             :   return NULL;
   36454             : }
   36455             : 
   36456             : 
   36457           0 : SWIGINTERN PyObject *_wrap_mapObj_applyConfigOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36458             :   PyObject *resultobj = 0;
   36459             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36460           0 :   void *argp1 = 0 ;
   36461             :   int res1 = 0 ;
   36462           0 :   PyObject * obj0 = 0 ;
   36463             :   
   36464           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_applyConfigOptions",&obj0)) SWIG_fail;
   36465           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36466           0 :   if (!SWIG_IsOK(res1)) {
   36467           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applyConfigOptions" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36468             :   }
   36469           0 :   arg1 = (struct mapObj *)(argp1);
   36470             :   {
   36471             :     mapObj_applyConfigOptions(arg1); {
   36472           0 :       errorObj *ms_error = msGetErrorObj();
   36473             :       
   36474           0 :       switch(ms_error->code) {
   36475             :       case MS_NOERR:
   36476             :         break;
   36477           0 :       case MS_NOTFOUND:
   36478           0 :         msResetErrorList();
   36479           0 :         break;
   36480             :       case -1:
   36481             :         break;
   36482           0 :       case MS_IOERR:
   36483           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36484           0 :           _raise_ms_exception();
   36485           0 :           msResetErrorList();
   36486           0 :           return NULL;
   36487             :         }
   36488             :       default:
   36489           0 :         _raise_ms_exception();
   36490           0 :         msResetErrorList();
   36491           0 :         return NULL;
   36492             :       }
   36493             :       
   36494             :     }
   36495             :   }
   36496             :   resultobj = SWIG_Py_Void();
   36497           0 :   return resultobj;
   36498           0 : fail:
   36499             :   return NULL;
   36500             : }
   36501             : 
   36502             : 
   36503           0 : SWIGINTERN PyObject *_wrap_mapObj_applySLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36504             :   PyObject *resultobj = 0;
   36505             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36506             :   char *arg2 = (char *) 0 ;
   36507           0 :   void *argp1 = 0 ;
   36508             :   int res1 = 0 ;
   36509             :   int res2 ;
   36510           0 :   char *buf2 = 0 ;
   36511           0 :   int alloc2 = 0 ;
   36512           0 :   PyObject * obj0 = 0 ;
   36513           0 :   PyObject * obj1 = 0 ;
   36514             :   int result;
   36515             :   
   36516           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_applySLD",&obj0,&obj1)) SWIG_fail;
   36517           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36518           0 :   if (!SWIG_IsOK(res1)) {
   36519           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applySLD" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36520             :   }
   36521           0 :   arg1 = (struct mapObj *)(argp1);
   36522           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36523           0 :   if (!SWIG_IsOK(res2)) {
   36524           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_applySLD" "', argument " "2"" of type '" "char *""'");
   36525             :   }
   36526           0 :   arg2 = (char *)(buf2);
   36527             :   {
   36528             :     result = (int)mapObj_applySLD(arg1,arg2); {
   36529           0 :       errorObj *ms_error = msGetErrorObj();
   36530             :       
   36531           0 :       switch(ms_error->code) {
   36532             :       case MS_NOERR:
   36533             :         break;
   36534           0 :       case MS_NOTFOUND:
   36535           0 :         msResetErrorList();
   36536           0 :         break;
   36537             :       case -1:
   36538             :         break;
   36539           0 :       case MS_IOERR:
   36540           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36541           0 :           _raise_ms_exception();
   36542           0 :           msResetErrorList();
   36543           0 :           return NULL;
   36544             :         }
   36545             :       default:
   36546           0 :         _raise_ms_exception();
   36547           0 :         msResetErrorList();
   36548           0 :         return NULL;
   36549             :       }
   36550             :       
   36551             :     }
   36552             :   }
   36553             :   resultobj = SWIG_From_int((int)(result));
   36554           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36555             :   return resultobj;
   36556           0 : fail:
   36557           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36558             :   return NULL;
   36559             : }
   36560             : 
   36561             : 
   36562           0 : SWIGINTERN PyObject *_wrap_mapObj_applySLDURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36563             :   PyObject *resultobj = 0;
   36564             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36565             :   char *arg2 = (char *) 0 ;
   36566           0 :   void *argp1 = 0 ;
   36567             :   int res1 = 0 ;
   36568             :   int res2 ;
   36569           0 :   char *buf2 = 0 ;
   36570           0 :   int alloc2 = 0 ;
   36571           0 :   PyObject * obj0 = 0 ;
   36572           0 :   PyObject * obj1 = 0 ;
   36573             :   int result;
   36574             :   
   36575           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_applySLDURL",&obj0,&obj1)) SWIG_fail;
   36576           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36577           0 :   if (!SWIG_IsOK(res1)) {
   36578           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applySLDURL" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36579             :   }
   36580           0 :   arg1 = (struct mapObj *)(argp1);
   36581           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36582           0 :   if (!SWIG_IsOK(res2)) {
   36583           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_applySLDURL" "', argument " "2"" of type '" "char *""'");
   36584             :   }
   36585           0 :   arg2 = (char *)(buf2);
   36586             :   {
   36587             :     result = (int)mapObj_applySLDURL(arg1,arg2); {
   36588           0 :       errorObj *ms_error = msGetErrorObj();
   36589             :       
   36590           0 :       switch(ms_error->code) {
   36591             :       case MS_NOERR:
   36592             :         break;
   36593           0 :       case MS_NOTFOUND:
   36594           0 :         msResetErrorList();
   36595           0 :         break;
   36596             :       case -1:
   36597             :         break;
   36598           0 :       case MS_IOERR:
   36599           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36600           0 :           _raise_ms_exception();
   36601           0 :           msResetErrorList();
   36602           0 :           return NULL;
   36603             :         }
   36604             :       default:
   36605           0 :         _raise_ms_exception();
   36606           0 :         msResetErrorList();
   36607           0 :         return NULL;
   36608             :       }
   36609             :       
   36610             :     }
   36611             :   }
   36612             :   resultobj = SWIG_From_int((int)(result));
   36613           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36614             :   return resultobj;
   36615           0 : fail:
   36616           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36617             :   return NULL;
   36618             : }
   36619             : 
   36620             : 
   36621           1 : SWIGINTERN PyObject *_wrap_mapObj_generateSLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36622             :   PyObject *resultobj = 0;
   36623             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36624             :   char *arg2 = (char *) NULL ;
   36625           1 :   void *argp1 = 0 ;
   36626             :   int res1 = 0 ;
   36627             :   int res2 ;
   36628           1 :   char *buf2 = 0 ;
   36629           1 :   int alloc2 = 0 ;
   36630           1 :   PyObject * obj0 = 0 ;
   36631           1 :   PyObject * obj1 = 0 ;
   36632             :   char *result = 0 ;
   36633             :   
   36634           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:mapObj_generateSLD",&obj0,&obj1)) SWIG_fail;
   36635           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36636           1 :   if (!SWIG_IsOK(res1)) {
   36637           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_generateSLD" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36638             :   }
   36639           1 :   arg1 = (struct mapObj *)(argp1);
   36640           1 :   if (obj1) {
   36641           1 :     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36642           1 :     if (!SWIG_IsOK(res2)) {
   36643           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_generateSLD" "', argument " "2"" of type '" "char *""'");
   36644             :     }
   36645           1 :     arg2 = (char *)(buf2);
   36646             :   }
   36647             :   {
   36648             :     result = (char *)mapObj_generateSLD(arg1,arg2); {
   36649           1 :       errorObj *ms_error = msGetErrorObj();
   36650             :       
   36651           1 :       switch(ms_error->code) {
   36652             :       case MS_NOERR:
   36653             :         break;
   36654           0 :       case MS_NOTFOUND:
   36655           0 :         msResetErrorList();
   36656           0 :         break;
   36657             :       case -1:
   36658             :         break;
   36659           0 :       case MS_IOERR:
   36660           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36661           0 :           _raise_ms_exception();
   36662           0 :           msResetErrorList();
   36663           0 :           return NULL;
   36664             :         }
   36665             :       default:
   36666           0 :         _raise_ms_exception();
   36667           0 :         msResetErrorList();
   36668           0 :         return NULL;
   36669             :       }
   36670             :       
   36671             :     }
   36672             :   }
   36673           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   36674           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36675           1 :   free((char*)result);
   36676           1 :   return resultobj;
   36677           0 : fail:
   36678           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36679             :   return NULL;
   36680             : }
   36681             : 
   36682             : 
   36683           0 : SWIGINTERN PyObject *_wrap_mapObj_processTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36684             :   PyObject *resultobj = 0;
   36685             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36686             :   int arg2 ;
   36687             :   char **arg3 = (char **) 0 ;
   36688             :   char **arg4 = (char **) 0 ;
   36689             :   int arg5 ;
   36690           0 :   void *argp1 = 0 ;
   36691             :   int res1 = 0 ;
   36692             :   int val2 ;
   36693             :   int ecode2 = 0 ;
   36694           0 :   void *argp3 = 0 ;
   36695             :   int res3 = 0 ;
   36696           0 :   void *argp4 = 0 ;
   36697             :   int res4 = 0 ;
   36698             :   int val5 ;
   36699             :   int ecode5 = 0 ;
   36700           0 :   PyObject * obj0 = 0 ;
   36701           0 :   PyObject * obj1 = 0 ;
   36702           0 :   PyObject * obj2 = 0 ;
   36703           0 :   PyObject * obj3 = 0 ;
   36704           0 :   PyObject * obj4 = 0 ;
   36705             :   char *result = 0 ;
   36706             :   
   36707           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:mapObj_processTemplate",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   36708           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36709           0 :   if (!SWIG_IsOK(res1)) {
   36710           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_processTemplate" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36711             :   }
   36712           0 :   arg1 = (struct mapObj *)(argp1);
   36713           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   36714           0 :   if (!SWIG_IsOK(ecode2)) {
   36715           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_processTemplate" "', argument " "2"" of type '" "int""'");
   36716             :   } 
   36717             :   arg2 = (int)(val2);
   36718           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 |  0 );
   36719           0 :   if (!SWIG_IsOK(res3)) {
   36720           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_processTemplate" "', argument " "3"" of type '" "char **""'"); 
   36721             :   }
   36722           0 :   arg3 = (char **)(argp3);
   36723           0 :   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
   36724           0 :   if (!SWIG_IsOK(res4)) {
   36725           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "mapObj_processTemplate" "', argument " "4"" of type '" "char **""'"); 
   36726             :   }
   36727           0 :   arg4 = (char **)(argp4);
   36728           0 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   36729           0 :   if (!SWIG_IsOK(ecode5)) {
   36730           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_processTemplate" "', argument " "5"" of type '" "int""'");
   36731             :   } 
   36732             :   arg5 = (int)(val5);
   36733             :   {
   36734             :     result = (char *)mapObj_processTemplate(arg1,arg2,arg3,arg4,arg5); {
   36735           0 :       errorObj *ms_error = msGetErrorObj();
   36736             :       
   36737           0 :       switch(ms_error->code) {
   36738             :       case MS_NOERR:
   36739             :         break;
   36740           0 :       case MS_NOTFOUND:
   36741           0 :         msResetErrorList();
   36742           0 :         break;
   36743             :       case -1:
   36744             :         break;
   36745           0 :       case MS_IOERR:
   36746           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36747           0 :           _raise_ms_exception();
   36748           0 :           msResetErrorList();
   36749           0 :           return NULL;
   36750             :         }
   36751             :       default:
   36752           0 :         _raise_ms_exception();
   36753           0 :         msResetErrorList();
   36754           0 :         return NULL;
   36755             :       }
   36756             :       
   36757             :     }
   36758             :   }
   36759           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   36760           0 :   free((char*)result);
   36761           0 :   return resultobj;
   36762           0 : fail:
   36763             :   return NULL;
   36764             : }
   36765             : 
   36766             : 
   36767           0 : SWIGINTERN PyObject *_wrap_mapObj_processLegendTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36768             :   PyObject *resultobj = 0;
   36769             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36770             :   char **arg2 = (char **) 0 ;
   36771             :   char **arg3 = (char **) 0 ;
   36772             :   int arg4 ;
   36773           0 :   void *argp1 = 0 ;
   36774             :   int res1 = 0 ;
   36775           0 :   void *argp2 = 0 ;
   36776             :   int res2 = 0 ;
   36777           0 :   void *argp3 = 0 ;
   36778             :   int res3 = 0 ;
   36779             :   int val4 ;
   36780             :   int ecode4 = 0 ;
   36781           0 :   PyObject * obj0 = 0 ;
   36782           0 :   PyObject * obj1 = 0 ;
   36783           0 :   PyObject * obj2 = 0 ;
   36784           0 :   PyObject * obj3 = 0 ;
   36785             :   char *result = 0 ;
   36786             :   
   36787           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_processLegendTemplate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   36788           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36789           0 :   if (!SWIG_IsOK(res1)) {
   36790           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_processLegendTemplate" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36791             :   }
   36792           0 :   arg1 = (struct mapObj *)(argp1);
   36793           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
   36794           0 :   if (!SWIG_IsOK(res2)) {
   36795           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_processLegendTemplate" "', argument " "2"" of type '" "char **""'"); 
   36796             :   }
   36797           0 :   arg2 = (char **)(argp2);
   36798           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 |  0 );
   36799           0 :   if (!SWIG_IsOK(res3)) {
   36800           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_processLegendTemplate" "', argument " "3"" of type '" "char **""'"); 
   36801             :   }
   36802           0 :   arg3 = (char **)(argp3);
   36803           0 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   36804           0 :   if (!SWIG_IsOK(ecode4)) {
   36805           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_processLegendTemplate" "', argument " "4"" of type '" "int""'");
   36806             :   } 
   36807             :   arg4 = (int)(val4);
   36808             :   {
   36809             :     result = (char *)mapObj_processLegendTemplate(arg1,arg2,arg3,arg4); {
   36810           0 :       errorObj *ms_error = msGetErrorObj();
   36811             :       
   36812           0 :       switch(ms_error->code) {
   36813             :       case MS_NOERR:
   36814             :         break;
   36815           0 :       case MS_NOTFOUND:
   36816           0 :         msResetErrorList();
   36817           0 :         break;
   36818             :       case -1:
   36819             :         break;
   36820           0 :       case MS_IOERR:
   36821           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36822           0 :           _raise_ms_exception();
   36823           0 :           msResetErrorList();
   36824           0 :           return NULL;
   36825             :         }
   36826             :       default:
   36827           0 :         _raise_ms_exception();
   36828           0 :         msResetErrorList();
   36829           0 :         return NULL;
   36830             :       }
   36831             :       
   36832             :     }
   36833             :   }
   36834           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   36835           0 :   free((char*)result);
   36836           0 :   return resultobj;
   36837           0 : fail:
   36838             :   return NULL;
   36839             : }
   36840             : 
   36841             : 
   36842           0 : SWIGINTERN PyObject *_wrap_mapObj_processQueryTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36843             :   PyObject *resultobj = 0;
   36844             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36845             :   char **arg2 = (char **) 0 ;
   36846             :   char **arg3 = (char **) 0 ;
   36847             :   int arg4 ;
   36848           0 :   void *argp1 = 0 ;
   36849             :   int res1 = 0 ;
   36850           0 :   void *argp2 = 0 ;
   36851             :   int res2 = 0 ;
   36852           0 :   void *argp3 = 0 ;
   36853             :   int res3 = 0 ;
   36854             :   int val4 ;
   36855             :   int ecode4 = 0 ;
   36856           0 :   PyObject * obj0 = 0 ;
   36857           0 :   PyObject * obj1 = 0 ;
   36858           0 :   PyObject * obj2 = 0 ;
   36859           0 :   PyObject * obj3 = 0 ;
   36860             :   char *result = 0 ;
   36861             :   
   36862           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_processQueryTemplate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   36863           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36864           0 :   if (!SWIG_IsOK(res1)) {
   36865           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_processQueryTemplate" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36866             :   }
   36867           0 :   arg1 = (struct mapObj *)(argp1);
   36868           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
   36869           0 :   if (!SWIG_IsOK(res2)) {
   36870           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_processQueryTemplate" "', argument " "2"" of type '" "char **""'"); 
   36871             :   }
   36872           0 :   arg2 = (char **)(argp2);
   36873           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 |  0 );
   36874           0 :   if (!SWIG_IsOK(res3)) {
   36875           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_processQueryTemplate" "', argument " "3"" of type '" "char **""'"); 
   36876             :   }
   36877           0 :   arg3 = (char **)(argp3);
   36878           0 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   36879           0 :   if (!SWIG_IsOK(ecode4)) {
   36880           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_processQueryTemplate" "', argument " "4"" of type '" "int""'");
   36881             :   } 
   36882             :   arg4 = (int)(val4);
   36883             :   {
   36884             :     result = (char *)mapObj_processQueryTemplate(arg1,arg2,arg3,arg4); {
   36885           0 :       errorObj *ms_error = msGetErrorObj();
   36886             :       
   36887           0 :       switch(ms_error->code) {
   36888             :       case MS_NOERR:
   36889             :         break;
   36890           0 :       case MS_NOTFOUND:
   36891           0 :         msResetErrorList();
   36892           0 :         break;
   36893             :       case -1:
   36894             :         break;
   36895           0 :       case MS_IOERR:
   36896           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36897           0 :           _raise_ms_exception();
   36898           0 :           msResetErrorList();
   36899           0 :           return NULL;
   36900             :         }
   36901             :       default:
   36902           0 :         _raise_ms_exception();
   36903           0 :         msResetErrorList();
   36904           0 :         return NULL;
   36905             :       }
   36906             :       
   36907             :     }
   36908             :   }
   36909           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   36910           0 :   free((char*)result);
   36911           0 :   return resultobj;
   36912           0 : fail:
   36913             :   return NULL;
   36914             : }
   36915             : 
   36916             : 
   36917           0 : SWIGINTERN PyObject *_wrap_mapObj_getOutputFormatByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36918             :   PyObject *resultobj = 0;
   36919             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36920             :   char *arg2 = (char *) 0 ;
   36921           0 :   void *argp1 = 0 ;
   36922             :   int res1 = 0 ;
   36923             :   int res2 ;
   36924           0 :   char *buf2 = 0 ;
   36925           0 :   int alloc2 = 0 ;
   36926           0 :   PyObject * obj0 = 0 ;
   36927           0 :   PyObject * obj1 = 0 ;
   36928             :   outputFormatObj *result = 0 ;
   36929             :   
   36930           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getOutputFormatByName",&obj0,&obj1)) SWIG_fail;
   36931           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36932           0 :   if (!SWIG_IsOK(res1)) {
   36933           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getOutputFormatByName" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36934             :   }
   36935           0 :   arg1 = (struct mapObj *)(argp1);
   36936           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   36937           0 :   if (!SWIG_IsOK(res2)) {
   36938           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getOutputFormatByName" "', argument " "2"" of type '" "char *""'");
   36939             :   }
   36940           0 :   arg2 = (char *)(buf2);
   36941             :   {
   36942             :     result = (outputFormatObj *)mapObj_getOutputFormatByName(arg1,arg2); {
   36943           0 :       errorObj *ms_error = msGetErrorObj();
   36944             :       
   36945           0 :       switch(ms_error->code) {
   36946             :       case MS_NOERR:
   36947             :         break;
   36948           0 :       case MS_NOTFOUND:
   36949           0 :         msResetErrorList();
   36950           0 :         break;
   36951             :       case -1:
   36952             :         break;
   36953           0 :       case MS_IOERR:
   36954           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   36955           0 :           _raise_ms_exception();
   36956           0 :           msResetErrorList();
   36957           0 :           return NULL;
   36958             :         }
   36959             :       default:
   36960           0 :         _raise_ms_exception();
   36961           0 :         msResetErrorList();
   36962           0 :         return NULL;
   36963             :       }
   36964             :       
   36965             :     }
   36966             :   }
   36967           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, 0 |  0 );
   36968           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36969             :   return resultobj;
   36970           0 : fail:
   36971           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   36972             :   return NULL;
   36973             : }
   36974             : 
   36975             : 
   36976           1 : SWIGINTERN PyObject *_wrap_mapObj_appendOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   36977             :   PyObject *resultobj = 0;
   36978             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   36979             :   outputFormatObj *arg2 = (outputFormatObj *) 0 ;
   36980           1 :   void *argp1 = 0 ;
   36981             :   int res1 = 0 ;
   36982           1 :   void *argp2 = 0 ;
   36983             :   int res2 = 0 ;
   36984           1 :   PyObject * obj0 = 0 ;
   36985           1 :   PyObject * obj1 = 0 ;
   36986             :   int result;
   36987             :   
   36988           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_appendOutputFormat",&obj0,&obj1)) SWIG_fail;
   36989           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   36990           1 :   if (!SWIG_IsOK(res1)) {
   36991           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_appendOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'"); 
   36992             :   }
   36993           1 :   arg1 = (struct mapObj *)(argp1);
   36994           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_outputFormatObj, 0 |  0 );
   36995           1 :   if (!SWIG_IsOK(res2)) {
   36996           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_appendOutputFormat" "', argument " "2"" of type '" "outputFormatObj *""'"); 
   36997             :   }
   36998           1 :   arg2 = (outputFormatObj *)(argp2);
   36999             :   {
   37000             :     result = (int)mapObj_appendOutputFormat(arg1,arg2); {
   37001           1 :       errorObj *ms_error = msGetErrorObj();
   37002             :       
   37003           1 :       switch(ms_error->code) {
   37004             :       case MS_NOERR:
   37005             :         break;
   37006           0 :       case MS_NOTFOUND:
   37007           0 :         msResetErrorList();
   37008           0 :         break;
   37009             :       case -1:
   37010             :         break;
   37011           0 :       case MS_IOERR:
   37012           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37013           0 :           _raise_ms_exception();
   37014           0 :           msResetErrorList();
   37015           0 :           return NULL;
   37016             :         }
   37017             :       default:
   37018           0 :         _raise_ms_exception();
   37019           0 :         msResetErrorList();
   37020           0 :         return NULL;
   37021             :       }
   37022             :       
   37023             :     }
   37024             :   }
   37025             :   resultobj = SWIG_From_int((int)(result));
   37026           1 :   return resultobj;
   37027           0 : fail:
   37028             :   return NULL;
   37029             : }
   37030             : 
   37031             : 
   37032           1 : SWIGINTERN PyObject *_wrap_mapObj_removeOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37033             :   PyObject *resultobj = 0;
   37034             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37035             :   char *arg2 = (char *) 0 ;
   37036           1 :   void *argp1 = 0 ;
   37037             :   int res1 = 0 ;
   37038             :   int res2 ;
   37039           1 :   char *buf2 = 0 ;
   37040           1 :   int alloc2 = 0 ;
   37041           1 :   PyObject * obj0 = 0 ;
   37042           1 :   PyObject * obj1 = 0 ;
   37043             :   int result;
   37044             :   
   37045           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_removeOutputFormat",&obj0,&obj1)) SWIG_fail;
   37046           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37047           1 :   if (!SWIG_IsOK(res1)) {
   37048           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_removeOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37049             :   }
   37050           1 :   arg1 = (struct mapObj *)(argp1);
   37051           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   37052           1 :   if (!SWIG_IsOK(res2)) {
   37053           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_removeOutputFormat" "', argument " "2"" of type '" "char *""'");
   37054             :   }
   37055           1 :   arg2 = (char *)(buf2);
   37056             :   {
   37057             :     result = (int)mapObj_removeOutputFormat(arg1,arg2); {
   37058           1 :       errorObj *ms_error = msGetErrorObj();
   37059             :       
   37060           1 :       switch(ms_error->code) {
   37061             :       case MS_NOERR:
   37062             :         break;
   37063           0 :       case MS_NOTFOUND:
   37064           0 :         msResetErrorList();
   37065           0 :         break;
   37066             :       case -1:
   37067             :         break;
   37068           0 :       case MS_IOERR:
   37069           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37070           0 :           _raise_ms_exception();
   37071           0 :           msResetErrorList();
   37072           0 :           return NULL;
   37073             :         }
   37074             :       default:
   37075           0 :         _raise_ms_exception();
   37076           0 :         msResetErrorList();
   37077           0 :         return NULL;
   37078             :       }
   37079             :       
   37080             :     }
   37081             :   }
   37082             :   resultobj = SWIG_From_int((int)(result));
   37083           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   37084             :   return resultobj;
   37085           0 : fail:
   37086           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   37087             :   return NULL;
   37088             : }
   37089             : 
   37090             : 
   37091           1 : SWIGINTERN PyObject *_wrap_mapObj_loadOWSParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37092             :   PyObject *resultobj = 0;
   37093             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37094             :   cgiRequestObj *arg2 = (cgiRequestObj *) 0 ;
   37095             :   char *arg3 = (char *) "1.1.1" ;
   37096           1 :   void *argp1 = 0 ;
   37097             :   int res1 = 0 ;
   37098           1 :   void *argp2 = 0 ;
   37099             :   int res2 = 0 ;
   37100             :   int res3 ;
   37101           1 :   char *buf3 = 0 ;
   37102           1 :   int alloc3 = 0 ;
   37103           1 :   PyObject * obj0 = 0 ;
   37104           1 :   PyObject * obj1 = 0 ;
   37105           1 :   PyObject * obj2 = 0 ;
   37106             :   int result;
   37107             :   
   37108           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_loadOWSParameters",&obj0,&obj1,&obj2)) SWIG_fail;
   37109           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37110           1 :   if (!SWIG_IsOK(res1)) {
   37111           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_loadOWSParameters" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37112             :   }
   37113           1 :   arg1 = (struct mapObj *)(argp1);
   37114           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   37115           1 :   if (!SWIG_IsOK(res2)) {
   37116           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_loadOWSParameters" "', argument " "2"" of type '" "cgiRequestObj *""'"); 
   37117             :   }
   37118           1 :   arg2 = (cgiRequestObj *)(argp2);
   37119           1 :   if (obj2) {
   37120           0 :     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   37121           0 :     if (!SWIG_IsOK(res3)) {
   37122           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_loadOWSParameters" "', argument " "3"" of type '" "char *""'");
   37123             :     }
   37124           0 :     arg3 = (char *)(buf3);
   37125             :   }
   37126             :   {
   37127             :     result = (int)mapObj_loadOWSParameters(arg1,arg2,arg3); {
   37128           1 :       errorObj *ms_error = msGetErrorObj();
   37129             :       
   37130           1 :       switch(ms_error->code) {
   37131             :       case MS_NOERR:
   37132             :         break;
   37133           0 :       case MS_NOTFOUND:
   37134           0 :         msResetErrorList();
   37135           0 :         break;
   37136             :       case -1:
   37137             :         break;
   37138           0 :       case MS_IOERR:
   37139           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37140           0 :           _raise_ms_exception();
   37141           0 :           msResetErrorList();
   37142           0 :           return NULL;
   37143             :         }
   37144             :       default:
   37145           0 :         _raise_ms_exception();
   37146           0 :         msResetErrorList();
   37147           0 :         return NULL;
   37148             :       }
   37149             :       
   37150             :     }
   37151             :   }
   37152             :   resultobj = SWIG_From_int((int)(result));
   37153           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   37154             :   return resultobj;
   37155           0 : fail:
   37156           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   37157             :   return NULL;
   37158             : }
   37159             : 
   37160             : 
   37161           1 : SWIGINTERN PyObject *_wrap_mapObj_OWSDispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37162             :   PyObject *resultobj = 0;
   37163             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37164             :   cgiRequestObj *arg2 = (cgiRequestObj *) 0 ;
   37165           1 :   void *argp1 = 0 ;
   37166             :   int res1 = 0 ;
   37167           1 :   void *argp2 = 0 ;
   37168             :   int res2 = 0 ;
   37169           1 :   PyObject * obj0 = 0 ;
   37170           1 :   PyObject * obj1 = 0 ;
   37171             :   int result;
   37172             :   
   37173           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_OWSDispatch",&obj0,&obj1)) SWIG_fail;
   37174           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37175           1 :   if (!SWIG_IsOK(res1)) {
   37176           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_OWSDispatch" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37177             :   }
   37178           1 :   arg1 = (struct mapObj *)(argp1);
   37179           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   37180           1 :   if (!SWIG_IsOK(res2)) {
   37181           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_OWSDispatch" "', argument " "2"" of type '" "cgiRequestObj *""'"); 
   37182             :   }
   37183           1 :   arg2 = (cgiRequestObj *)(argp2);
   37184             :   {
   37185             :     result = (int)mapObj_OWSDispatch(arg1,arg2); {
   37186           1 :       errorObj *ms_error = msGetErrorObj();
   37187             :       
   37188           1 :       switch(ms_error->code) {
   37189             :       case MS_NOERR:
   37190             :         break;
   37191           0 :       case MS_NOTFOUND:
   37192           0 :         msResetErrorList();
   37193           0 :         break;
   37194             :       case -1:
   37195             :         break;
   37196           0 :       case MS_IOERR:
   37197           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37198           0 :           _raise_ms_exception();
   37199           0 :           msResetErrorList();
   37200           0 :           return NULL;
   37201             :         }
   37202             :       default:
   37203           0 :         _raise_ms_exception();
   37204           0 :         msResetErrorList();
   37205           0 :         return NULL;
   37206             :       }
   37207             :       
   37208             :     }
   37209             :   }
   37210             :   resultobj = SWIG_From_int((int)(result));
   37211           1 :   return resultobj;
   37212           0 : fail:
   37213             :   return NULL;
   37214             : }
   37215             : 
   37216             : 
   37217           0 : SWIGINTERN PyObject *_wrap_mapObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37218             :   PyObject *resultobj = 0;
   37219             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37220           0 :   void *argp1 = 0 ;
   37221             :   int res1 = 0 ;
   37222           0 :   PyObject * obj0 = 0 ;
   37223             :   char *result = 0 ;
   37224             :   
   37225           0 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_convertToString",&obj0)) SWIG_fail;
   37226           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37227           0 :   if (!SWIG_IsOK(res1)) {
   37228           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_convertToString" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37229             :   }
   37230           0 :   arg1 = (struct mapObj *)(argp1);
   37231             :   {
   37232             :     result = (char *)mapObj_convertToString(arg1); {
   37233           0 :       errorObj *ms_error = msGetErrorObj();
   37234             :       
   37235           0 :       switch(ms_error->code) {
   37236             :       case MS_NOERR:
   37237             :         break;
   37238           0 :       case MS_NOTFOUND:
   37239           0 :         msResetErrorList();
   37240           0 :         break;
   37241             :       case -1:
   37242             :         break;
   37243           0 :       case MS_IOERR:
   37244           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37245           0 :           _raise_ms_exception();
   37246           0 :           msResetErrorList();
   37247           0 :           return NULL;
   37248             :         }
   37249             :       default:
   37250           0 :         _raise_ms_exception();
   37251           0 :         msResetErrorList();
   37252           0 :         return NULL;
   37253             :       }
   37254             :       
   37255             :     }
   37256             :   }
   37257           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   37258           0 :   free((char*)result);
   37259           0 :   return resultobj;
   37260           0 : fail:
   37261             :   return NULL;
   37262             : }
   37263             : 
   37264             : 
   37265           1 : SWIGINTERN PyObject *_wrap_mapObj_applyDefaultSubstitutions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37266             :   PyObject *resultobj = 0;
   37267             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37268           1 :   void *argp1 = 0 ;
   37269             :   int res1 = 0 ;
   37270           1 :   PyObject * obj0 = 0 ;
   37271             :   
   37272           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_applyDefaultSubstitutions",&obj0)) SWIG_fail;
   37273           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37274           1 :   if (!SWIG_IsOK(res1)) {
   37275           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applyDefaultSubstitutions" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37276             :   }
   37277           1 :   arg1 = (struct mapObj *)(argp1);
   37278             :   {
   37279             :     mapObj_applyDefaultSubstitutions(arg1); {
   37280           1 :       errorObj *ms_error = msGetErrorObj();
   37281             :       
   37282           1 :       switch(ms_error->code) {
   37283             :       case MS_NOERR:
   37284             :         break;
   37285           0 :       case MS_NOTFOUND:
   37286           0 :         msResetErrorList();
   37287           0 :         break;
   37288             :       case -1:
   37289             :         break;
   37290           0 :       case MS_IOERR:
   37291           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37292           0 :           _raise_ms_exception();
   37293           0 :           msResetErrorList();
   37294           0 :           return NULL;
   37295             :         }
   37296             :       default:
   37297           0 :         _raise_ms_exception();
   37298           0 :         msResetErrorList();
   37299           0 :         return NULL;
   37300             :       }
   37301             :       
   37302             :     }
   37303             :   }
   37304             :   resultobj = SWIG_Py_Void();
   37305           1 :   return resultobj;
   37306           0 : fail:
   37307             :   return NULL;
   37308             : }
   37309             : 
   37310             : 
   37311           1 : SWIGINTERN PyObject *_wrap_mapObj_applySubstitutions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37312             :   PyObject *resultobj = 0;
   37313             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37314             :   char **arg2 = (char **) 0 ;
   37315             :   char **arg3 = (char **) 0 ;
   37316             :   int arg4 ;
   37317           1 :   void *argp1 = 0 ;
   37318             :   int res1 = 0 ;
   37319           1 :   PyObject * obj0 = 0 ;
   37320           1 :   PyObject * obj1 = 0 ;
   37321             :   
   37322           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_applySubstitutions",&obj0,&obj1)) SWIG_fail;
   37323           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37324           1 :   if (!SWIG_IsOK(res1)) {
   37325           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applySubstitutions" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37326             :   }
   37327           1 :   arg1 = (struct mapObj *)(argp1);
   37328             :   {
   37329             :     /* Check if is a dict */
   37330           1 :     if (PyDict_Check(obj1)) {
   37331             :       int i = 0;
   37332           1 :       int size = (int) PyDict_Size(obj1);
   37333             :       
   37334           1 :       PyObject* keys = PyDict_Keys(obj1);
   37335           1 :       PyObject* values = PyDict_Values(obj1);
   37336             :       
   37337             :       arg4 = size;
   37338           1 :       arg2 = (char **) malloc((size+1)*sizeof(char *));
   37339           1 :       arg3 = (char **) malloc((size+1)*sizeof(char *));
   37340             :       
   37341           1 :       for (i = 0; i < size; i++) {
   37342           1 :         PyObject* key = PyList_GetItem(keys, i);
   37343           1 :         PyObject* val = PyList_GetItem(values, i);
   37344             :         
   37345             : #if PY_MAJOR_VERSION >= 3
   37346             :         // Changed in version 3.7: The return type is now const char * rather than char *
   37347             :         // avoid warning C4090: '=': different 'const' qualifiers
   37348           1 :         arg2[i] = (char *)PyUnicode_AsUTF8(key);
   37349           1 :         arg3[i] = (char *)PyUnicode_AsUTF8(val);
   37350             : #else
   37351             :         arg2[i] = PyString_AsString(key);
   37352             :         arg3[i] = PyString_AsString(val);
   37353             : #endif
   37354             :       }
   37355             :       
   37356           1 :       arg2[i] = 0;
   37357           1 :       arg3[i] = 0;
   37358             :       
   37359             :     } else {
   37360           0 :       PyErr_SetString(PyExc_TypeError, "Input not a dictionary");
   37361           0 :       SWIG_fail;
   37362             :     }
   37363             :   }
   37364             :   {
   37365             :     mapObj_applySubstitutions(arg1,arg2,arg3,arg4); {
   37366           1 :       errorObj *ms_error = msGetErrorObj();
   37367             :       
   37368           1 :       switch(ms_error->code) {
   37369             :       case MS_NOERR:
   37370             :         break;
   37371           0 :       case MS_NOTFOUND:
   37372           0 :         msResetErrorList();
   37373           0 :         break;
   37374             :       case -1:
   37375             :         break;
   37376           0 :       case MS_IOERR:
   37377           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37378           0 :           _raise_ms_exception();
   37379           0 :           msResetErrorList();
   37380           0 :           return NULL;
   37381             :         }
   37382             :       default:
   37383           0 :         _raise_ms_exception();
   37384           0 :         msResetErrorList();
   37385           0 :         return NULL;
   37386             :       }
   37387             :       
   37388             :     }
   37389             :   }
   37390             :   resultobj = SWIG_Py_Void();
   37391             :   {
   37392           1 :     free((char *) arg2);
   37393           1 :     free((char *) arg3);
   37394             :   }
   37395           1 :   return resultobj;
   37396           0 : fail:
   37397             :   {
   37398             :     free((char *) arg2);
   37399             :     free((char *) arg3);
   37400             :   }
   37401           0 :   return NULL;
   37402             : }
   37403             : 
   37404             : 
   37405           1 : SWIGINTERN PyObject *_wrap_mapObj_zoomPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37406             :   PyObject *resultobj = 0;
   37407             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37408             :   int arg2 ;
   37409             :   pointObj *arg3 = (pointObj *) 0 ;
   37410             :   int arg4 ;
   37411             :   int arg5 ;
   37412             :   rectObj *arg6 = (rectObj *) 0 ;
   37413             :   rectObj *arg7 = (rectObj *) 0 ;
   37414           1 :   void *argp1 = 0 ;
   37415             :   int res1 = 0 ;
   37416             :   int val2 ;
   37417             :   int ecode2 = 0 ;
   37418           1 :   void *argp3 = 0 ;
   37419             :   int res3 = 0 ;
   37420             :   int val4 ;
   37421             :   int ecode4 = 0 ;
   37422             :   int val5 ;
   37423             :   int ecode5 = 0 ;
   37424           1 :   void *argp6 = 0 ;
   37425             :   int res6 = 0 ;
   37426           1 :   void *argp7 = 0 ;
   37427             :   int res7 = 0 ;
   37428           1 :   PyObject * obj0 = 0 ;
   37429           1 :   PyObject * obj1 = 0 ;
   37430           1 :   PyObject * obj2 = 0 ;
   37431           1 :   PyObject * obj3 = 0 ;
   37432           1 :   PyObject * obj4 = 0 ;
   37433           1 :   PyObject * obj5 = 0 ;
   37434           1 :   PyObject * obj6 = 0 ;
   37435             :   int result;
   37436             :   
   37437           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:mapObj_zoomPoint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
   37438           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37439           1 :   if (!SWIG_IsOK(res1)) {
   37440           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_zoomPoint" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37441             :   }
   37442           1 :   arg1 = (struct mapObj *)(argp1);
   37443           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   37444           1 :   if (!SWIG_IsOK(ecode2)) {
   37445           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_zoomPoint" "', argument " "2"" of type '" "int""'");
   37446             :   } 
   37447             :   arg2 = (int)(val2);
   37448           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 |  0 );
   37449           1 :   if (!SWIG_IsOK(res3)) {
   37450           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_zoomPoint" "', argument " "3"" of type '" "pointObj *""'"); 
   37451             :   }
   37452           1 :   arg3 = (pointObj *)(argp3);
   37453           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   37454           1 :   if (!SWIG_IsOK(ecode4)) {
   37455           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_zoomPoint" "', argument " "4"" of type '" "int""'");
   37456             :   } 
   37457             :   arg4 = (int)(val4);
   37458           1 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   37459           1 :   if (!SWIG_IsOK(ecode5)) {
   37460           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_zoomPoint" "', argument " "5"" of type '" "int""'");
   37461             :   } 
   37462             :   arg5 = (int)(val5);
   37463           1 :   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_rectObj, 0 |  0 );
   37464           1 :   if (!SWIG_IsOK(res6)) {
   37465           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "mapObj_zoomPoint" "', argument " "6"" of type '" "rectObj *""'"); 
   37466             :   }
   37467           1 :   arg6 = (rectObj *)(argp6);
   37468           1 :   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_rectObj, 0 |  0 );
   37469           1 :   if (!SWIG_IsOK(res7)) {
   37470           0 :     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "mapObj_zoomPoint" "', argument " "7"" of type '" "rectObj *""'"); 
   37471             :   }
   37472           1 :   arg7 = (rectObj *)(argp7);
   37473             :   {
   37474           1 :     result = (int)mapObj_zoomPoint(arg1,arg2,arg3,arg4,arg5,arg6,arg7); {
   37475           1 :       errorObj *ms_error = msGetErrorObj();
   37476             :       
   37477           1 :       switch(ms_error->code) {
   37478             :       case MS_NOERR:
   37479             :         break;
   37480           0 :       case MS_NOTFOUND:
   37481           0 :         msResetErrorList();
   37482           0 :         break;
   37483             :       case -1:
   37484             :         break;
   37485           0 :       case MS_IOERR:
   37486           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37487           0 :           _raise_ms_exception();
   37488           0 :           msResetErrorList();
   37489           0 :           return NULL;
   37490             :         }
   37491             :       default:
   37492           1 :         _raise_ms_exception();
   37493           1 :         msResetErrorList();
   37494           1 :         return NULL;
   37495             :       }
   37496             :       
   37497             :     }
   37498             :   }
   37499             :   resultobj = SWIG_From_int((int)(result));
   37500           1 :   return resultobj;
   37501           0 : fail:
   37502             :   return NULL;
   37503             : }
   37504             : 
   37505             : 
   37506           1 : SWIGINTERN PyObject *_wrap_mapObj_zoomRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37507             :   PyObject *resultobj = 0;
   37508             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37509             :   rectObj *arg2 = (rectObj *) 0 ;
   37510             :   int arg3 ;
   37511             :   int arg4 ;
   37512             :   rectObj *arg5 = (rectObj *) 0 ;
   37513             :   rectObj *arg6 = (rectObj *) 0 ;
   37514           1 :   void *argp1 = 0 ;
   37515             :   int res1 = 0 ;
   37516           1 :   void *argp2 = 0 ;
   37517             :   int res2 = 0 ;
   37518             :   int val3 ;
   37519             :   int ecode3 = 0 ;
   37520             :   int val4 ;
   37521             :   int ecode4 = 0 ;
   37522           1 :   void *argp5 = 0 ;
   37523             :   int res5 = 0 ;
   37524           1 :   void *argp6 = 0 ;
   37525             :   int res6 = 0 ;
   37526           1 :   PyObject * obj0 = 0 ;
   37527           1 :   PyObject * obj1 = 0 ;
   37528           1 :   PyObject * obj2 = 0 ;
   37529           1 :   PyObject * obj3 = 0 ;
   37530           1 :   PyObject * obj4 = 0 ;
   37531           1 :   PyObject * obj5 = 0 ;
   37532             :   int result;
   37533             :   
   37534           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:mapObj_zoomRectangle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   37535           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37536           1 :   if (!SWIG_IsOK(res1)) {
   37537           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_zoomRectangle" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37538             :   }
   37539           1 :   arg1 = (struct mapObj *)(argp1);
   37540           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 |  0 );
   37541           1 :   if (!SWIG_IsOK(res2)) {
   37542           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_zoomRectangle" "', argument " "2"" of type '" "rectObj *""'"); 
   37543             :   }
   37544           1 :   arg2 = (rectObj *)(argp2);
   37545           1 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   37546           1 :   if (!SWIG_IsOK(ecode3)) {
   37547           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_zoomRectangle" "', argument " "3"" of type '" "int""'");
   37548             :   } 
   37549             :   arg3 = (int)(val3);
   37550           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   37551           1 :   if (!SWIG_IsOK(ecode4)) {
   37552           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_zoomRectangle" "', argument " "4"" of type '" "int""'");
   37553             :   } 
   37554             :   arg4 = (int)(val4);
   37555           1 :   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_rectObj, 0 |  0 );
   37556           1 :   if (!SWIG_IsOK(res5)) {
   37557           0 :     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "mapObj_zoomRectangle" "', argument " "5"" of type '" "rectObj *""'"); 
   37558             :   }
   37559           1 :   arg5 = (rectObj *)(argp5);
   37560           1 :   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_rectObj, 0 |  0 );
   37561           1 :   if (!SWIG_IsOK(res6)) {
   37562           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "mapObj_zoomRectangle" "', argument " "6"" of type '" "rectObj *""'"); 
   37563             :   }
   37564           1 :   arg6 = (rectObj *)(argp6);
   37565             :   {
   37566           1 :     result = (int)mapObj_zoomRectangle(arg1,arg2,arg3,arg4,arg5,arg6); {
   37567           1 :       errorObj *ms_error = msGetErrorObj();
   37568             :       
   37569           1 :       switch(ms_error->code) {
   37570             :       case MS_NOERR:
   37571             :         break;
   37572           0 :       case MS_NOTFOUND:
   37573           0 :         msResetErrorList();
   37574           0 :         break;
   37575             :       case -1:
   37576             :         break;
   37577           0 :       case MS_IOERR:
   37578           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37579           0 :           _raise_ms_exception();
   37580           0 :           msResetErrorList();
   37581           0 :           return NULL;
   37582             :         }
   37583             :       default:
   37584           1 :         _raise_ms_exception();
   37585           1 :         msResetErrorList();
   37586           1 :         return NULL;
   37587             :       }
   37588             :       
   37589             :     }
   37590             :   }
   37591             :   resultobj = SWIG_From_int((int)(result));
   37592           1 :   return resultobj;
   37593           0 : fail:
   37594             :   return NULL;
   37595             : }
   37596             : 
   37597             : 
   37598           1 : SWIGINTERN PyObject *_wrap_mapObj_zoomScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37599             :   PyObject *resultobj = 0;
   37600             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37601             :   double arg2 ;
   37602             :   pointObj *arg3 = (pointObj *) 0 ;
   37603             :   int arg4 ;
   37604             :   int arg5 ;
   37605             :   rectObj *arg6 = (rectObj *) 0 ;
   37606             :   rectObj *arg7 = (rectObj *) 0 ;
   37607           1 :   void *argp1 = 0 ;
   37608             :   int res1 = 0 ;
   37609             :   double val2 ;
   37610             :   int ecode2 = 0 ;
   37611           1 :   void *argp3 = 0 ;
   37612             :   int res3 = 0 ;
   37613             :   int val4 ;
   37614             :   int ecode4 = 0 ;
   37615             :   int val5 ;
   37616             :   int ecode5 = 0 ;
   37617           1 :   void *argp6 = 0 ;
   37618             :   int res6 = 0 ;
   37619           1 :   void *argp7 = 0 ;
   37620             :   int res7 = 0 ;
   37621           1 :   PyObject * obj0 = 0 ;
   37622           1 :   PyObject * obj1 = 0 ;
   37623           1 :   PyObject * obj2 = 0 ;
   37624           1 :   PyObject * obj3 = 0 ;
   37625           1 :   PyObject * obj4 = 0 ;
   37626           1 :   PyObject * obj5 = 0 ;
   37627           1 :   PyObject * obj6 = 0 ;
   37628             :   int result;
   37629             :   
   37630           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:mapObj_zoomScale",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
   37631           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37632           1 :   if (!SWIG_IsOK(res1)) {
   37633           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_zoomScale" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37634             :   }
   37635           1 :   arg1 = (struct mapObj *)(argp1);
   37636           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   37637           1 :   if (!SWIG_IsOK(ecode2)) {
   37638           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_zoomScale" "', argument " "2"" of type '" "double""'");
   37639             :   } 
   37640           1 :   arg2 = (double)(val2);
   37641           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 |  0 );
   37642           1 :   if (!SWIG_IsOK(res3)) {
   37643           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_zoomScale" "', argument " "3"" of type '" "pointObj *""'"); 
   37644             :   }
   37645           1 :   arg3 = (pointObj *)(argp3);
   37646           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   37647           1 :   if (!SWIG_IsOK(ecode4)) {
   37648           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_zoomScale" "', argument " "4"" of type '" "int""'");
   37649             :   } 
   37650             :   arg4 = (int)(val4);
   37651           1 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   37652           1 :   if (!SWIG_IsOK(ecode5)) {
   37653           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_zoomScale" "', argument " "5"" of type '" "int""'");
   37654             :   } 
   37655             :   arg5 = (int)(val5);
   37656           1 :   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_rectObj, 0 |  0 );
   37657           1 :   if (!SWIG_IsOK(res6)) {
   37658           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "mapObj_zoomScale" "', argument " "6"" of type '" "rectObj *""'"); 
   37659             :   }
   37660           1 :   arg6 = (rectObj *)(argp6);
   37661           1 :   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_rectObj, 0 |  0 );
   37662           1 :   if (!SWIG_IsOK(res7)) {
   37663           0 :     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "mapObj_zoomScale" "', argument " "7"" of type '" "rectObj *""'"); 
   37664             :   }
   37665           1 :   arg7 = (rectObj *)(argp7);
   37666             :   {
   37667           1 :     result = (int)mapObj_zoomScale(arg1,arg2,arg3,arg4,arg5,arg6,arg7); {
   37668           1 :       errorObj *ms_error = msGetErrorObj();
   37669             :       
   37670           1 :       switch(ms_error->code) {
   37671             :       case MS_NOERR:
   37672             :         break;
   37673           0 :       case MS_NOTFOUND:
   37674           0 :         msResetErrorList();
   37675           0 :         break;
   37676             :       case -1:
   37677             :         break;
   37678           0 :       case MS_IOERR:
   37679           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37680           0 :           _raise_ms_exception();
   37681           0 :           msResetErrorList();
   37682           0 :           return NULL;
   37683             :         }
   37684             :       default:
   37685           0 :         _raise_ms_exception();
   37686           0 :         msResetErrorList();
   37687           0 :         return NULL;
   37688             :       }
   37689             :       
   37690             :     }
   37691             :   }
   37692             :   resultobj = SWIG_From_int((int)(result));
   37693           1 :   return resultobj;
   37694           0 : fail:
   37695             :   return NULL;
   37696             : }
   37697             : 
   37698             : 
   37699           1 : SWIGINTERN PyObject *_wrap_mapObj_getLayerOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37700             :   PyObject *resultobj = 0;
   37701             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37702           1 :   void *argp1 = 0 ;
   37703             :   int res1 = 0 ;
   37704           1 :   PyObject * obj0 = 0 ;
   37705             :   PyObject *result = 0 ;
   37706             :   
   37707           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getLayerOrder",&obj0)) SWIG_fail;
   37708           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37709           1 :   if (!SWIG_IsOK(res1)) {
   37710           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayerOrder" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37711             :   }
   37712           1 :   arg1 = (struct mapObj *)(argp1);
   37713             :   {
   37714           1 :     result = (PyObject *)mapObj_getLayerOrder(arg1); {
   37715           1 :       errorObj *ms_error = msGetErrorObj();
   37716             :       
   37717           1 :       switch(ms_error->code) {
   37718             :       case MS_NOERR:
   37719             :         break;
   37720           0 :       case MS_NOTFOUND:
   37721           0 :         msResetErrorList();
   37722           0 :         break;
   37723             :       case -1:
   37724             :         break;
   37725           0 :       case MS_IOERR:
   37726           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37727           0 :           _raise_ms_exception();
   37728           0 :           msResetErrorList();
   37729           0 :           return NULL;
   37730             :         }
   37731             :       default:
   37732           0 :         _raise_ms_exception();
   37733           0 :         msResetErrorList();
   37734           0 :         return NULL;
   37735             :       }
   37736             :       
   37737             :     }
   37738             :   }
   37739             :   resultobj = result;
   37740             :   return resultobj;
   37741           0 : fail:
   37742             :   return NULL;
   37743             : }
   37744             : 
   37745             : 
   37746           1 : SWIGINTERN PyObject *_wrap_mapObj_setLayerOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37747             :   PyObject *resultobj = 0;
   37748             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37749             :   PyObject *arg2 = (PyObject *) 0 ;
   37750           1 :   void *argp1 = 0 ;
   37751             :   int res1 = 0 ;
   37752           1 :   PyObject * obj0 = 0 ;
   37753           1 :   PyObject * obj1 = 0 ;
   37754             :   int result;
   37755             :   
   37756           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setLayerOrder",&obj0,&obj1)) SWIG_fail;
   37757           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37758           1 :   if (!SWIG_IsOK(res1)) {
   37759           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setLayerOrder" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37760             :   }
   37761           1 :   arg1 = (struct mapObj *)(argp1);
   37762           1 :   arg2 = obj1;
   37763             :   {
   37764           1 :     result = (int)mapObj_setLayerOrder(arg1,arg2); {
   37765           1 :       errorObj *ms_error = msGetErrorObj();
   37766             :       
   37767           1 :       switch(ms_error->code) {
   37768             :       case MS_NOERR:
   37769             :         break;
   37770           0 :       case MS_NOTFOUND:
   37771           0 :         msResetErrorList();
   37772           0 :         break;
   37773             :       case -1:
   37774             :         break;
   37775           0 :       case MS_IOERR:
   37776           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37777           0 :           _raise_ms_exception();
   37778           0 :           msResetErrorList();
   37779           0 :           return NULL;
   37780             :         }
   37781             :       default:
   37782           0 :         _raise_ms_exception();
   37783           0 :         msResetErrorList();
   37784           0 :         return NULL;
   37785             :       }
   37786             :       
   37787             :     }
   37788             :   }
   37789             :   resultobj = SWIG_From_int((int)(result));
   37790           1 :   return resultobj;
   37791           0 : fail:
   37792             :   return NULL;
   37793             : }
   37794             : 
   37795             : 
   37796           1 : SWIGINTERN PyObject *_wrap_mapObj_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37797             :   PyObject *resultobj = 0;
   37798             :   struct mapObj *arg1 = (struct mapObj *) 0 ;
   37799           1 :   void *argp1 = 0 ;
   37800             :   int res1 = 0 ;
   37801           1 :   PyObject * obj0 = 0 ;
   37802             :   PyObject *result = 0 ;
   37803             :   
   37804           1 :   if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getSize",&obj0)) SWIG_fail;
   37805           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37806           1 :   if (!SWIG_IsOK(res1)) {
   37807           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getSize" "', argument " "1"" of type '" "struct mapObj *""'"); 
   37808             :   }
   37809           1 :   arg1 = (struct mapObj *)(argp1);
   37810             :   {
   37811           1 :     result = (PyObject *)mapObj_getSize(arg1); {
   37812           1 :       errorObj *ms_error = msGetErrorObj();
   37813             :       
   37814           1 :       switch(ms_error->code) {
   37815             :       case MS_NOERR:
   37816             :         break;
   37817           0 :       case MS_NOTFOUND:
   37818           0 :         msResetErrorList();
   37819           0 :         break;
   37820             :       case -1:
   37821             :         break;
   37822           0 :       case MS_IOERR:
   37823           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37824           0 :           _raise_ms_exception();
   37825           0 :           msResetErrorList();
   37826           0 :           return NULL;
   37827             :         }
   37828             :       default:
   37829           0 :         _raise_ms_exception();
   37830           0 :         msResetErrorList();
   37831           0 :         return NULL;
   37832             :       }
   37833             :       
   37834             :     }
   37835             :   }
   37836             :   resultobj = result;
   37837             :   return resultobj;
   37838           0 : fail:
   37839             :   return NULL;
   37840             : }
   37841             : 
   37842             : 
   37843           1 : SWIGINTERN PyObject *mapObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37844             :   PyObject *obj;
   37845           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   37846           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_mapObj, SWIG_NewClientData(obj));
   37847           1 :   return SWIG_Py_Void();
   37848             : }
   37849             : 
   37850           0 : SWIGINTERN PyObject *_wrap_msSaveImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37851             :   PyObject *resultobj = 0;
   37852             :   mapObj *arg1 = (mapObj *) 0 ;
   37853             :   imageObj *arg2 = (imageObj *) 0 ;
   37854             :   char *arg3 = (char *) 0 ;
   37855           0 :   void *argp1 = 0 ;
   37856             :   int res1 = 0 ;
   37857           0 :   void *argp2 = 0 ;
   37858             :   int res2 = 0 ;
   37859             :   int res3 ;
   37860           0 :   char *buf3 = 0 ;
   37861           0 :   int alloc3 = 0 ;
   37862           0 :   PyObject * obj0 = 0 ;
   37863           0 :   PyObject * obj1 = 0 ;
   37864           0 :   PyObject * obj2 = 0 ;
   37865             :   int result;
   37866             :   
   37867           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:msSaveImage",&obj0,&obj1,&obj2)) SWIG_fail;
   37868           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 |  0 );
   37869           0 :   if (!SWIG_IsOK(res1)) {
   37870           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msSaveImage" "', argument " "1"" of type '" "mapObj *""'"); 
   37871             :   }
   37872           0 :   arg1 = (mapObj *)(argp1);
   37873           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 |  0 );
   37874           0 :   if (!SWIG_IsOK(res2)) {
   37875           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "msSaveImage" "', argument " "2"" of type '" "imageObj *""'"); 
   37876             :   }
   37877           0 :   arg2 = (imageObj *)(argp2);
   37878           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   37879           0 :   if (!SWIG_IsOK(res3)) {
   37880           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "msSaveImage" "', argument " "3"" of type '" "char const *""'");
   37881             :   }
   37882           0 :   arg3 = (char *)(buf3);
   37883             :   {
   37884           0 :     result = (int)msSaveImage(arg1,arg2,(char const *)arg3); {
   37885           0 :       errorObj *ms_error = msGetErrorObj();
   37886             :       
   37887           0 :       switch(ms_error->code) {
   37888             :       case MS_NOERR:
   37889             :         break;
   37890           0 :       case MS_NOTFOUND:
   37891           0 :         msResetErrorList();
   37892           0 :         break;
   37893             :       case -1:
   37894             :         break;
   37895           0 :       case MS_IOERR:
   37896           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37897           0 :           _raise_ms_exception();
   37898           0 :           msResetErrorList();
   37899           0 :           return NULL;
   37900             :         }
   37901             :       default:
   37902           0 :         _raise_ms_exception();
   37903           0 :         msResetErrorList();
   37904           0 :         return NULL;
   37905             :       }
   37906             :       
   37907             :     }
   37908             :   }
   37909             :   resultobj = SWIG_From_int((int)(result));
   37910           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   37911             :   return resultobj;
   37912           0 : fail:
   37913           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   37914             :   return NULL;
   37915             : }
   37916             : 
   37917             : 
   37918           0 : SWIGINTERN PyObject *_wrap_msFreeImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37919             :   PyObject *resultobj = 0;
   37920             :   imageObj *arg1 = (imageObj *) 0 ;
   37921           0 :   void *argp1 = 0 ;
   37922             :   int res1 = 0 ;
   37923           0 :   PyObject * obj0 = 0 ;
   37924             :   
   37925           0 :   if (!PyArg_ParseTuple(args,(char *)"O:msFreeImage",&obj0)) SWIG_fail;
   37926           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 |  0 );
   37927           0 :   if (!SWIG_IsOK(res1)) {
   37928           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msFreeImage" "', argument " "1"" of type '" "imageObj *""'"); 
   37929             :   }
   37930           0 :   arg1 = (imageObj *)(argp1);
   37931             :   {
   37932           0 :     msFreeImage(arg1); {
   37933           0 :       errorObj *ms_error = msGetErrorObj();
   37934             :       
   37935           0 :       switch(ms_error->code) {
   37936             :       case MS_NOERR:
   37937             :         break;
   37938           0 :       case MS_NOTFOUND:
   37939           0 :         msResetErrorList();
   37940           0 :         break;
   37941             :       case -1:
   37942             :         break;
   37943           0 :       case MS_IOERR:
   37944           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37945           0 :           _raise_ms_exception();
   37946           0 :           msResetErrorList();
   37947           0 :           return NULL;
   37948             :         }
   37949             :       default:
   37950           0 :         _raise_ms_exception();
   37951           0 :         msResetErrorList();
   37952           0 :         return NULL;
   37953             :       }
   37954             :       
   37955             :     }
   37956             :   }
   37957             :   resultobj = SWIG_Py_Void();
   37958           0 :   return resultobj;
   37959           0 : fail:
   37960             :   return NULL;
   37961             : }
   37962             : 
   37963             : 
   37964           0 : SWIGINTERN PyObject *_wrap_msSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   37965             :   PyObject *resultobj = 0;
   37966             :   int result;
   37967             :   
   37968           0 :   if (!PyArg_ParseTuple(args,(char *)":msSetup")) SWIG_fail;
   37969             :   {
   37970           0 :     result = (int)msSetup(); {
   37971           0 :       errorObj *ms_error = msGetErrorObj();
   37972             :       
   37973           0 :       switch(ms_error->code) {
   37974             :       case MS_NOERR:
   37975             :         break;
   37976           0 :       case MS_NOTFOUND:
   37977           0 :         msResetErrorList();
   37978           0 :         break;
   37979             :       case -1:
   37980             :         break;
   37981           0 :       case MS_IOERR:
   37982           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   37983           0 :           _raise_ms_exception();
   37984           0 :           msResetErrorList();
   37985           0 :           return NULL;
   37986             :         }
   37987             :       default:
   37988           0 :         _raise_ms_exception();
   37989           0 :         msResetErrorList();
   37990           0 :         return NULL;
   37991             :       }
   37992             :       
   37993             :     }
   37994             :   }
   37995             :   resultobj = SWIG_From_int((int)(result));
   37996           0 :   return resultobj;
   37997           0 : fail:
   37998             :   return NULL;
   37999             : }
   38000             : 
   38001             : 
   38002           0 : SWIGINTERN PyObject *_wrap_msCleanup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38003             :   PyObject *resultobj = 0;
   38004             :   
   38005           0 :   if (!PyArg_ParseTuple(args,(char *)":msCleanup")) SWIG_fail;
   38006             :   {
   38007           0 :     msCleanup(); {
   38008           0 :       errorObj *ms_error = msGetErrorObj();
   38009             :       
   38010           0 :       switch(ms_error->code) {
   38011             :       case MS_NOERR:
   38012             :         break;
   38013           0 :       case MS_NOTFOUND:
   38014           0 :         msResetErrorList();
   38015           0 :         break;
   38016             :       case -1:
   38017             :         break;
   38018           0 :       case MS_IOERR:
   38019           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38020           0 :           _raise_ms_exception();
   38021           0 :           msResetErrorList();
   38022           0 :           return NULL;
   38023             :         }
   38024             :       default:
   38025           0 :         _raise_ms_exception();
   38026           0 :         msResetErrorList();
   38027           0 :         return NULL;
   38028             :       }
   38029             :       
   38030             :     }
   38031             :   }
   38032             :   resultobj = SWIG_Py_Void();
   38033           0 :   return resultobj;
   38034           0 : fail:
   38035             :   return NULL;
   38036             : }
   38037             : 
   38038             : 
   38039           1 : SWIGINTERN PyObject *_wrap_msLoadMapFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38040             :   PyObject *resultobj = 0;
   38041             :   char *arg1 = (char *) 0 ;
   38042             :   char *arg2 = (char *) 0 ;
   38043             :   int res1 ;
   38044           1 :   char *buf1 = 0 ;
   38045           1 :   int alloc1 = 0 ;
   38046             :   int res2 ;
   38047           1 :   char *buf2 = 0 ;
   38048           1 :   int alloc2 = 0 ;
   38049           1 :   PyObject * obj0 = 0 ;
   38050           1 :   PyObject * obj1 = 0 ;
   38051             :   mapObj *result = 0 ;
   38052             :   
   38053           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:msLoadMapFromString",&obj0,&obj1)) SWIG_fail;
   38054           1 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   38055           1 :   if (!SWIG_IsOK(res1)) {
   38056           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msLoadMapFromString" "', argument " "1"" of type '" "char *""'");
   38057             :   }
   38058           1 :   arg1 = (char *)(buf1);
   38059           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   38060           1 :   if (!SWIG_IsOK(res2)) {
   38061           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "msLoadMapFromString" "', argument " "2"" of type '" "char *""'");
   38062             :   }
   38063           1 :   arg2 = (char *)(buf2);
   38064             :   {
   38065           1 :     result = (mapObj *)msLoadMapFromString(arg1,arg2); {
   38066           1 :       errorObj *ms_error = msGetErrorObj();
   38067             :       
   38068           1 :       switch(ms_error->code) {
   38069             :       case MS_NOERR:
   38070             :         break;
   38071           0 :       case MS_NOTFOUND:
   38072           0 :         msResetErrorList();
   38073           0 :         break;
   38074             :       case -1:
   38075             :         break;
   38076           0 :       case MS_IOERR:
   38077           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38078           0 :           _raise_ms_exception();
   38079           0 :           msResetErrorList();
   38080           0 :           return NULL;
   38081             :         }
   38082             :       default:
   38083           0 :         _raise_ms_exception();
   38084           0 :         msResetErrorList();
   38085           0 :         return NULL;
   38086             :       }
   38087             :       
   38088             :     }
   38089             :   }
   38090           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, SWIG_POINTER_OWN |  0 );
   38091           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   38092           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   38093             :   return resultobj;
   38094           0 : fail:
   38095           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   38096           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   38097             :   return NULL;
   38098             : }
   38099             : 
   38100             : 
   38101           1 : SWIGINTERN PyObject *_wrap_rectObj_minx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38102             :   PyObject *resultobj = 0;
   38103             :   rectObj *arg1 = (rectObj *) 0 ;
   38104             :   double arg2 ;
   38105           1 :   void *argp1 = 0 ;
   38106             :   int res1 = 0 ;
   38107             :   double val2 ;
   38108             :   int ecode2 = 0 ;
   38109           1 :   PyObject * obj0 = 0 ;
   38110           1 :   PyObject * obj1 = 0 ;
   38111             :   
   38112           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_minx_set",&obj0,&obj1)) SWIG_fail;
   38113           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38114           1 :   if (!SWIG_IsOK(res1)) {
   38115           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_minx_set" "', argument " "1"" of type '" "rectObj *""'"); 
   38116             :   }
   38117           1 :   arg1 = (rectObj *)(argp1);
   38118           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   38119           1 :   if (!SWIG_IsOK(ecode2)) {
   38120           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_minx_set" "', argument " "2"" of type '" "double""'");
   38121             :   } 
   38122           1 :   arg2 = (double)(val2);
   38123           1 :   if (arg1) (arg1)->minx = arg2;
   38124             :   resultobj = SWIG_Py_Void();
   38125           1 :   return resultobj;
   38126           0 : fail:
   38127             :   return NULL;
   38128             : }
   38129             : 
   38130             : 
   38131           1 : SWIGINTERN PyObject *_wrap_rectObj_minx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38132             :   PyObject *resultobj = 0;
   38133             :   rectObj *arg1 = (rectObj *) 0 ;
   38134           1 :   void *argp1 = 0 ;
   38135             :   int res1 = 0 ;
   38136           1 :   PyObject * obj0 = 0 ;
   38137             :   double result;
   38138             :   
   38139           1 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_minx_get",&obj0)) SWIG_fail;
   38140           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38141           1 :   if (!SWIG_IsOK(res1)) {
   38142           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_minx_get" "', argument " "1"" of type '" "rectObj *""'"); 
   38143             :   }
   38144           1 :   arg1 = (rectObj *)(argp1);
   38145           1 :   result = (double) ((arg1)->minx);
   38146           1 :   resultobj = SWIG_From_double((double)(result));
   38147           1 :   return resultobj;
   38148           0 : fail:
   38149             :   return NULL;
   38150             : }
   38151             : 
   38152             : 
   38153           1 : SWIGINTERN PyObject *_wrap_rectObj_miny_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38154             :   PyObject *resultobj = 0;
   38155             :   rectObj *arg1 = (rectObj *) 0 ;
   38156             :   double arg2 ;
   38157           1 :   void *argp1 = 0 ;
   38158             :   int res1 = 0 ;
   38159             :   double val2 ;
   38160             :   int ecode2 = 0 ;
   38161           1 :   PyObject * obj0 = 0 ;
   38162           1 :   PyObject * obj1 = 0 ;
   38163             :   
   38164           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_miny_set",&obj0,&obj1)) SWIG_fail;
   38165           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38166           1 :   if (!SWIG_IsOK(res1)) {
   38167           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_miny_set" "', argument " "1"" of type '" "rectObj *""'"); 
   38168             :   }
   38169           1 :   arg1 = (rectObj *)(argp1);
   38170           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   38171           1 :   if (!SWIG_IsOK(ecode2)) {
   38172           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_miny_set" "', argument " "2"" of type '" "double""'");
   38173             :   } 
   38174           1 :   arg2 = (double)(val2);
   38175           1 :   if (arg1) (arg1)->miny = arg2;
   38176             :   resultobj = SWIG_Py_Void();
   38177           1 :   return resultobj;
   38178           0 : fail:
   38179             :   return NULL;
   38180             : }
   38181             : 
   38182             : 
   38183           1 : SWIGINTERN PyObject *_wrap_rectObj_miny_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38184             :   PyObject *resultobj = 0;
   38185             :   rectObj *arg1 = (rectObj *) 0 ;
   38186           1 :   void *argp1 = 0 ;
   38187             :   int res1 = 0 ;
   38188           1 :   PyObject * obj0 = 0 ;
   38189             :   double result;
   38190             :   
   38191           1 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_miny_get",&obj0)) SWIG_fail;
   38192           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38193           1 :   if (!SWIG_IsOK(res1)) {
   38194           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_miny_get" "', argument " "1"" of type '" "rectObj *""'"); 
   38195             :   }
   38196           1 :   arg1 = (rectObj *)(argp1);
   38197           1 :   result = (double) ((arg1)->miny);
   38198           1 :   resultobj = SWIG_From_double((double)(result));
   38199           1 :   return resultobj;
   38200           0 : fail:
   38201             :   return NULL;
   38202             : }
   38203             : 
   38204             : 
   38205           1 : SWIGINTERN PyObject *_wrap_rectObj_maxx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38206             :   PyObject *resultobj = 0;
   38207             :   rectObj *arg1 = (rectObj *) 0 ;
   38208             :   double arg2 ;
   38209           1 :   void *argp1 = 0 ;
   38210             :   int res1 = 0 ;
   38211             :   double val2 ;
   38212             :   int ecode2 = 0 ;
   38213           1 :   PyObject * obj0 = 0 ;
   38214           1 :   PyObject * obj1 = 0 ;
   38215             :   
   38216           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_maxx_set",&obj0,&obj1)) SWIG_fail;
   38217           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38218           1 :   if (!SWIG_IsOK(res1)) {
   38219           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxx_set" "', argument " "1"" of type '" "rectObj *""'"); 
   38220             :   }
   38221           1 :   arg1 = (rectObj *)(argp1);
   38222           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   38223           1 :   if (!SWIG_IsOK(ecode2)) {
   38224           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_maxx_set" "', argument " "2"" of type '" "double""'");
   38225             :   } 
   38226           1 :   arg2 = (double)(val2);
   38227           1 :   if (arg1) (arg1)->maxx = arg2;
   38228             :   resultobj = SWIG_Py_Void();
   38229           1 :   return resultobj;
   38230           0 : fail:
   38231             :   return NULL;
   38232             : }
   38233             : 
   38234             : 
   38235           1 : SWIGINTERN PyObject *_wrap_rectObj_maxx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38236             :   PyObject *resultobj = 0;
   38237             :   rectObj *arg1 = (rectObj *) 0 ;
   38238           1 :   void *argp1 = 0 ;
   38239             :   int res1 = 0 ;
   38240           1 :   PyObject * obj0 = 0 ;
   38241             :   double result;
   38242             :   
   38243           1 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_maxx_get",&obj0)) SWIG_fail;
   38244           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38245           1 :   if (!SWIG_IsOK(res1)) {
   38246           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxx_get" "', argument " "1"" of type '" "rectObj *""'"); 
   38247             :   }
   38248           1 :   arg1 = (rectObj *)(argp1);
   38249           1 :   result = (double) ((arg1)->maxx);
   38250           1 :   resultobj = SWIG_From_double((double)(result));
   38251           1 :   return resultobj;
   38252           0 : fail:
   38253             :   return NULL;
   38254             : }
   38255             : 
   38256             : 
   38257           1 : SWIGINTERN PyObject *_wrap_rectObj_maxy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38258             :   PyObject *resultobj = 0;
   38259             :   rectObj *arg1 = (rectObj *) 0 ;
   38260             :   double arg2 ;
   38261           1 :   void *argp1 = 0 ;
   38262             :   int res1 = 0 ;
   38263             :   double val2 ;
   38264             :   int ecode2 = 0 ;
   38265           1 :   PyObject * obj0 = 0 ;
   38266           1 :   PyObject * obj1 = 0 ;
   38267             :   
   38268           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_maxy_set",&obj0,&obj1)) SWIG_fail;
   38269           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38270           1 :   if (!SWIG_IsOK(res1)) {
   38271           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxy_set" "', argument " "1"" of type '" "rectObj *""'"); 
   38272             :   }
   38273           1 :   arg1 = (rectObj *)(argp1);
   38274           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   38275           1 :   if (!SWIG_IsOK(ecode2)) {
   38276           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_maxy_set" "', argument " "2"" of type '" "double""'");
   38277             :   } 
   38278           1 :   arg2 = (double)(val2);
   38279           1 :   if (arg1) (arg1)->maxy = arg2;
   38280             :   resultobj = SWIG_Py_Void();
   38281           1 :   return resultobj;
   38282           0 : fail:
   38283             :   return NULL;
   38284             : }
   38285             : 
   38286             : 
   38287           1 : SWIGINTERN PyObject *_wrap_rectObj_maxy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38288             :   PyObject *resultobj = 0;
   38289             :   rectObj *arg1 = (rectObj *) 0 ;
   38290           1 :   void *argp1 = 0 ;
   38291             :   int res1 = 0 ;
   38292           1 :   PyObject * obj0 = 0 ;
   38293             :   double result;
   38294             :   
   38295           1 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_maxy_get",&obj0)) SWIG_fail;
   38296           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38297           1 :   if (!SWIG_IsOK(res1)) {
   38298           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxy_get" "', argument " "1"" of type '" "rectObj *""'"); 
   38299             :   }
   38300           1 :   arg1 = (rectObj *)(argp1);
   38301           1 :   result = (double) ((arg1)->maxy);
   38302           1 :   resultobj = SWIG_From_double((double)(result));
   38303           1 :   return resultobj;
   38304           0 : fail:
   38305             :   return NULL;
   38306             : }
   38307             : 
   38308             : 
   38309           1 : SWIGINTERN PyObject *_wrap_new_rectObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38310             :   PyObject *resultobj = 0;
   38311             :   double arg1 = (double) -1.0 ;
   38312             :   double arg2 = (double) -1.0 ;
   38313             :   double arg3 = (double) -1.0 ;
   38314             :   double arg4 = (double) -1.0 ;
   38315             :   int arg5 = (int) 0 ;
   38316             :   double val1 ;
   38317             :   int ecode1 = 0 ;
   38318             :   double val2 ;
   38319             :   int ecode2 = 0 ;
   38320             :   double val3 ;
   38321             :   int ecode3 = 0 ;
   38322             :   double val4 ;
   38323             :   int ecode4 = 0 ;
   38324             :   int val5 ;
   38325             :   int ecode5 = 0 ;
   38326           1 :   PyObject * obj0 = 0 ;
   38327           1 :   PyObject * obj1 = 0 ;
   38328           1 :   PyObject * obj2 = 0 ;
   38329           1 :   PyObject * obj3 = 0 ;
   38330           1 :   PyObject * obj4 = 0 ;
   38331             :   rectObj *result = 0 ;
   38332             :   
   38333           1 :   if (!PyArg_ParseTuple(args,(char *)"|OOOOO:new_rectObj",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   38334           1 :   if (obj0) {
   38335           1 :     ecode1 = SWIG_AsVal_double(obj0, &val1);
   38336           1 :     if (!SWIG_IsOK(ecode1)) {
   38337           0 :       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_rectObj" "', argument " "1"" of type '" "double""'");
   38338             :     } 
   38339           1 :     arg1 = (double)(val1);
   38340             :   }
   38341           1 :   if (obj1) {
   38342           1 :     ecode2 = SWIG_AsVal_double(obj1, &val2);
   38343           1 :     if (!SWIG_IsOK(ecode2)) {
   38344           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_rectObj" "', argument " "2"" of type '" "double""'");
   38345             :     } 
   38346           1 :     arg2 = (double)(val2);
   38347             :   }
   38348           1 :   if (obj2) {
   38349           1 :     ecode3 = SWIG_AsVal_double(obj2, &val3);
   38350           1 :     if (!SWIG_IsOK(ecode3)) {
   38351           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_rectObj" "', argument " "3"" of type '" "double""'");
   38352             :     } 
   38353           1 :     arg3 = (double)(val3);
   38354             :   }
   38355           1 :   if (obj3) {
   38356           1 :     ecode4 = SWIG_AsVal_double(obj3, &val4);
   38357           1 :     if (!SWIG_IsOK(ecode4)) {
   38358           0 :       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_rectObj" "', argument " "4"" of type '" "double""'");
   38359             :     } 
   38360           1 :     arg4 = (double)(val4);
   38361             :   }
   38362           1 :   if (obj4) {
   38363             :     ecode5 = SWIG_AsVal_int(obj4, &val5);
   38364           1 :     if (!SWIG_IsOK(ecode5)) {
   38365           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_rectObj" "', argument " "5"" of type '" "int""'");
   38366             :     } 
   38367             :     arg5 = (int)(val5);
   38368             :   }
   38369             :   {
   38370           1 :     result = (rectObj *)new_rectObj(arg1,arg2,arg3,arg4,arg5); {
   38371           1 :       errorObj *ms_error = msGetErrorObj();
   38372             :       
   38373           1 :       switch(ms_error->code) {
   38374             :       case MS_NOERR:
   38375             :         break;
   38376           0 :       case MS_NOTFOUND:
   38377           0 :         msResetErrorList();
   38378           0 :         break;
   38379             :       case -1:
   38380             :         break;
   38381           0 :       case MS_IOERR:
   38382           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38383           0 :           _raise_ms_exception();
   38384           0 :           msResetErrorList();
   38385           0 :           return NULL;
   38386             :         }
   38387             :       default:
   38388           1 :         _raise_ms_exception();
   38389           1 :         msResetErrorList();
   38390           1 :         return NULL;
   38391             :       }
   38392             :       
   38393             :     }
   38394             :   }
   38395           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, SWIG_POINTER_NEW |  0 );
   38396           1 :   return resultobj;
   38397           0 : fail:
   38398             :   return NULL;
   38399             : }
   38400             : 
   38401             : 
   38402           1 : SWIGINTERN PyObject *_wrap_delete_rectObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38403             :   PyObject *resultobj = 0;
   38404             :   rectObj *arg1 = (rectObj *) 0 ;
   38405           1 :   void *argp1 = 0 ;
   38406             :   int res1 = 0 ;
   38407           1 :   PyObject * obj0 = 0 ;
   38408             :   
   38409           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_rectObj",&obj0)) SWIG_fail;
   38410           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, SWIG_POINTER_DISOWN |  0 );
   38411           1 :   if (!SWIG_IsOK(res1)) {
   38412           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_rectObj" "', argument " "1"" of type '" "rectObj *""'"); 
   38413             :   }
   38414           1 :   arg1 = (rectObj *)(argp1);
   38415             :   {
   38416             :     delete_rectObj(arg1); {
   38417           1 :       errorObj *ms_error = msGetErrorObj();
   38418             :       
   38419           1 :       switch(ms_error->code) {
   38420             :       case MS_NOERR:
   38421             :         break;
   38422           0 :       case MS_NOTFOUND:
   38423           0 :         msResetErrorList();
   38424           0 :         break;
   38425             :       case -1:
   38426             :         break;
   38427           0 :       case MS_IOERR:
   38428           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38429           0 :           _raise_ms_exception();
   38430           0 :           msResetErrorList();
   38431           0 :           return NULL;
   38432             :         }
   38433             :       default:
   38434           0 :         _raise_ms_exception();
   38435           0 :         msResetErrorList();
   38436           0 :         return NULL;
   38437             :       }
   38438             :       
   38439             :     }
   38440             :   }
   38441             :   resultobj = SWIG_Py_Void();
   38442           1 :   return resultobj;
   38443           0 : fail:
   38444             :   return NULL;
   38445             : }
   38446             : 
   38447             : 
   38448           0 : SWIGINTERN PyObject *_wrap_rectObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38449             :   PyObject *resultobj = 0;
   38450             :   rectObj *arg1 = (rectObj *) 0 ;
   38451             :   projectionObj *arg2 = (projectionObj *) 0 ;
   38452             :   projectionObj *arg3 = (projectionObj *) 0 ;
   38453           0 :   void *argp1 = 0 ;
   38454             :   int res1 = 0 ;
   38455           0 :   void *argp2 = 0 ;
   38456             :   int res2 = 0 ;
   38457           0 :   void *argp3 = 0 ;
   38458             :   int res3 = 0 ;
   38459           0 :   PyObject * obj0 = 0 ;
   38460           0 :   PyObject * obj1 = 0 ;
   38461           0 :   PyObject * obj2 = 0 ;
   38462             :   int result;
   38463             :   
   38464           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:rectObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
   38465           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38466           0 :   if (!SWIG_IsOK(res1)) {
   38467           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_project" "', argument " "1"" of type '" "rectObj *""'"); 
   38468             :   }
   38469           0 :   arg1 = (rectObj *)(argp1);
   38470           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 |  0 );
   38471           0 :   if (!SWIG_IsOK(res2)) {
   38472           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rectObj_project" "', argument " "2"" of type '" "projectionObj *""'"); 
   38473             :   }
   38474           0 :   arg2 = (projectionObj *)(argp2);
   38475           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 |  0 );
   38476           0 :   if (!SWIG_IsOK(res3)) {
   38477           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rectObj_project" "', argument " "3"" of type '" "projectionObj *""'"); 
   38478             :   }
   38479           0 :   arg3 = (projectionObj *)(argp3);
   38480             :   {
   38481             :     result = (int)rectObj_project(arg1,arg2,arg3); {
   38482           0 :       errorObj *ms_error = msGetErrorObj();
   38483             :       
   38484           0 :       switch(ms_error->code) {
   38485             :       case MS_NOERR:
   38486             :         break;
   38487           0 :       case MS_NOTFOUND:
   38488           0 :         msResetErrorList();
   38489           0 :         break;
   38490             :       case -1:
   38491             :         break;
   38492           0 :       case MS_IOERR:
   38493           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38494           0 :           _raise_ms_exception();
   38495           0 :           msResetErrorList();
   38496           0 :           return NULL;
   38497             :         }
   38498             :       default:
   38499           0 :         _raise_ms_exception();
   38500           0 :         msResetErrorList();
   38501           0 :         return NULL;
   38502             :       }
   38503             :       
   38504             :     }
   38505             :   }
   38506             :   resultobj = SWIG_From_int((int)(result));
   38507           0 :   return resultobj;
   38508           0 : fail:
   38509             :   return NULL;
   38510             : }
   38511             : 
   38512             : 
   38513           0 : SWIGINTERN PyObject *_wrap_rectObj_fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38514             :   PyObject *resultobj = 0;
   38515             :   rectObj *arg1 = (rectObj *) 0 ;
   38516             :   int arg2 ;
   38517             :   int arg3 ;
   38518           0 :   void *argp1 = 0 ;
   38519             :   int res1 = 0 ;
   38520             :   int val2 ;
   38521             :   int ecode2 = 0 ;
   38522             :   int val3 ;
   38523             :   int ecode3 = 0 ;
   38524           0 :   PyObject * obj0 = 0 ;
   38525           0 :   PyObject * obj1 = 0 ;
   38526           0 :   PyObject * obj2 = 0 ;
   38527             :   double result;
   38528             :   
   38529           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:rectObj_fit",&obj0,&obj1,&obj2)) SWIG_fail;
   38530           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38531           0 :   if (!SWIG_IsOK(res1)) {
   38532           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_fit" "', argument " "1"" of type '" "rectObj *""'"); 
   38533             :   }
   38534           0 :   arg1 = (rectObj *)(argp1);
   38535           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   38536           0 :   if (!SWIG_IsOK(ecode2)) {
   38537           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_fit" "', argument " "2"" of type '" "int""'");
   38538             :   } 
   38539             :   arg2 = (int)(val2);
   38540           0 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   38541           0 :   if (!SWIG_IsOK(ecode3)) {
   38542           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rectObj_fit" "', argument " "3"" of type '" "int""'");
   38543             :   } 
   38544             :   arg3 = (int)(val3);
   38545             :   {
   38546             :     result = (double)rectObj_fit(arg1,arg2,arg3); {
   38547           0 :       errorObj *ms_error = msGetErrorObj();
   38548             :       
   38549           0 :       switch(ms_error->code) {
   38550             :       case MS_NOERR:
   38551             :         break;
   38552           0 :       case MS_NOTFOUND:
   38553           0 :         msResetErrorList();
   38554           0 :         break;
   38555             :       case -1:
   38556             :         break;
   38557           0 :       case MS_IOERR:
   38558           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38559           0 :           _raise_ms_exception();
   38560           0 :           msResetErrorList();
   38561           0 :           return NULL;
   38562             :         }
   38563             :       default:
   38564           0 :         _raise_ms_exception();
   38565           0 :         msResetErrorList();
   38566           0 :         return NULL;
   38567             :       }
   38568             :       
   38569             :     }
   38570             :   }
   38571           0 :   resultobj = SWIG_From_double((double)(result));
   38572           0 :   return resultobj;
   38573           0 : fail:
   38574             :   return NULL;
   38575             : }
   38576             : 
   38577             : 
   38578           0 : SWIGINTERN PyObject *_wrap_rectObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38579             :   PyObject *resultobj = 0;
   38580             :   rectObj *arg1 = (rectObj *) 0 ;
   38581             :   mapObj *arg2 = (mapObj *) 0 ;
   38582             :   layerObj *arg3 = (layerObj *) 0 ;
   38583             :   imageObj *arg4 = (imageObj *) 0 ;
   38584             :   int arg5 ;
   38585             :   char *arg6 = (char *) 0 ;
   38586           0 :   void *argp1 = 0 ;
   38587             :   int res1 = 0 ;
   38588           0 :   void *argp2 = 0 ;
   38589             :   int res2 = 0 ;
   38590           0 :   void *argp3 = 0 ;
   38591             :   int res3 = 0 ;
   38592           0 :   void *argp4 = 0 ;
   38593             :   int res4 = 0 ;
   38594             :   int val5 ;
   38595             :   int ecode5 = 0 ;
   38596             :   int res6 ;
   38597           0 :   char *buf6 = 0 ;
   38598           0 :   int alloc6 = 0 ;
   38599           0 :   PyObject * obj0 = 0 ;
   38600           0 :   PyObject * obj1 = 0 ;
   38601           0 :   PyObject * obj2 = 0 ;
   38602           0 :   PyObject * obj3 = 0 ;
   38603           0 :   PyObject * obj4 = 0 ;
   38604           0 :   PyObject * obj5 = 0 ;
   38605             :   int result;
   38606             :   
   38607           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:rectObj_draw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   38608           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38609           0 :   if (!SWIG_IsOK(res1)) {
   38610           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_draw" "', argument " "1"" of type '" "rectObj *""'"); 
   38611             :   }
   38612           0 :   arg1 = (rectObj *)(argp1);
   38613           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   38614           0 :   if (!SWIG_IsOK(res2)) {
   38615           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rectObj_draw" "', argument " "2"" of type '" "mapObj *""'"); 
   38616             :   }
   38617           0 :   arg2 = (mapObj *)(argp2);
   38618           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 |  0 );
   38619           0 :   if (!SWIG_IsOK(res3)) {
   38620           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rectObj_draw" "', argument " "3"" of type '" "layerObj *""'"); 
   38621             :   }
   38622           0 :   arg3 = (layerObj *)(argp3);
   38623           0 :   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_imageObj, 0 |  0 );
   38624           0 :   if (!SWIG_IsOK(res4)) {
   38625           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "rectObj_draw" "', argument " "4"" of type '" "imageObj *""'"); 
   38626             :   }
   38627           0 :   arg4 = (imageObj *)(argp4);
   38628           0 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   38629           0 :   if (!SWIG_IsOK(ecode5)) {
   38630           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "rectObj_draw" "', argument " "5"" of type '" "int""'");
   38631             :   } 
   38632             :   arg5 = (int)(val5);
   38633           0 :   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
   38634           0 :   if (!SWIG_IsOK(res6)) {
   38635           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "rectObj_draw" "', argument " "6"" of type '" "char *""'");
   38636             :   }
   38637           0 :   arg6 = (char *)(buf6);
   38638             :   {
   38639           0 :     result = (int)rectObj_draw(arg1,arg2,arg3,arg4,arg5,arg6); {
   38640           0 :       errorObj *ms_error = msGetErrorObj();
   38641             :       
   38642           0 :       switch(ms_error->code) {
   38643             :       case MS_NOERR:
   38644             :         break;
   38645           0 :       case MS_NOTFOUND:
   38646           0 :         msResetErrorList();
   38647           0 :         break;
   38648             :       case -1:
   38649             :         break;
   38650           0 :       case MS_IOERR:
   38651           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38652           0 :           _raise_ms_exception();
   38653           0 :           msResetErrorList();
   38654           0 :           return NULL;
   38655             :         }
   38656             :       default:
   38657           0 :         _raise_ms_exception();
   38658           0 :         msResetErrorList();
   38659           0 :         return NULL;
   38660             :       }
   38661             :       
   38662             :     }
   38663             :   }
   38664             :   resultobj = SWIG_From_int((int)(result));
   38665           0 :   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
   38666             :   return resultobj;
   38667           0 : fail:
   38668           0 :   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
   38669             :   return NULL;
   38670             : }
   38671             : 
   38672             : 
   38673           0 : SWIGINTERN PyObject *_wrap_rectObj_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38674             :   PyObject *resultobj = 0;
   38675             :   rectObj *arg1 = (rectObj *) 0 ;
   38676           0 :   void *argp1 = 0 ;
   38677             :   int res1 = 0 ;
   38678           0 :   PyObject * obj0 = 0 ;
   38679             :   pointObj *result = 0 ;
   38680             :   
   38681           0 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_getCenter",&obj0)) SWIG_fail;
   38682           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38683           0 :   if (!SWIG_IsOK(res1)) {
   38684           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_getCenter" "', argument " "1"" of type '" "rectObj *""'"); 
   38685             :   }
   38686           0 :   arg1 = (rectObj *)(argp1);
   38687             :   {
   38688           0 :     result = (pointObj *)rectObj_getCenter(arg1); {
   38689           0 :       errorObj *ms_error = msGetErrorObj();
   38690             :       
   38691           0 :       switch(ms_error->code) {
   38692             :       case MS_NOERR:
   38693             :         break;
   38694           0 :       case MS_NOTFOUND:
   38695           0 :         msResetErrorList();
   38696           0 :         break;
   38697             :       case -1:
   38698             :         break;
   38699           0 :       case MS_IOERR:
   38700           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38701           0 :           _raise_ms_exception();
   38702           0 :           msResetErrorList();
   38703           0 :           return NULL;
   38704             :         }
   38705             :       default:
   38706           0 :         _raise_ms_exception();
   38707           0 :         msResetErrorList();
   38708           0 :         return NULL;
   38709             :       }
   38710             :       
   38711             :     }
   38712             :   }
   38713           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_OWN |  0 );
   38714           0 :   return resultobj;
   38715           0 : fail:
   38716             :   return NULL;
   38717             : }
   38718             : 
   38719             : 
   38720           1 : SWIGINTERN PyObject *_wrap_rectObj_toPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38721             :   PyObject *resultobj = 0;
   38722             :   rectObj *arg1 = (rectObj *) 0 ;
   38723           1 :   void *argp1 = 0 ;
   38724             :   int res1 = 0 ;
   38725           1 :   PyObject * obj0 = 0 ;
   38726             :   shapeObj *result = 0 ;
   38727             :   
   38728           1 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_toPolygon",&obj0)) SWIG_fail;
   38729           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38730           1 :   if (!SWIG_IsOK(res1)) {
   38731           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_toPolygon" "', argument " "1"" of type '" "rectObj *""'"); 
   38732             :   }
   38733           1 :   arg1 = (rectObj *)(argp1);
   38734             :   {
   38735           1 :     result = (shapeObj *)rectObj_toPolygon(arg1); {
   38736           1 :       errorObj *ms_error = msGetErrorObj();
   38737             :       
   38738           1 :       switch(ms_error->code) {
   38739             :       case MS_NOERR:
   38740             :         break;
   38741           0 :       case MS_NOTFOUND:
   38742           0 :         msResetErrorList();
   38743           0 :         break;
   38744             :       case -1:
   38745             :         break;
   38746           0 :       case MS_IOERR:
   38747           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38748           0 :           _raise_ms_exception();
   38749           0 :           msResetErrorList();
   38750           0 :           return NULL;
   38751             :         }
   38752             :       default:
   38753           0 :         _raise_ms_exception();
   38754           0 :         msResetErrorList();
   38755           0 :         return NULL;
   38756             :       }
   38757             :       
   38758             :     }
   38759             :   }
   38760           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   38761           1 :   return resultobj;
   38762           0 : fail:
   38763             :   return NULL;
   38764             : }
   38765             : 
   38766             : 
   38767           1 : SWIGINTERN PyObject *_wrap_rectObj_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38768             :   PyObject *resultobj = 0;
   38769             :   rectObj *arg1 = (rectObj *) 0 ;
   38770           1 :   void *argp1 = 0 ;
   38771             :   int res1 = 0 ;
   38772           1 :   PyObject * obj0 = 0 ;
   38773             :   char *result = 0 ;
   38774             :   
   38775           1 :   if (!PyArg_ParseTuple(args,(char *)"O:rectObj_toString",&obj0)) SWIG_fail;
   38776           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 |  0 );
   38777           1 :   if (!SWIG_IsOK(res1)) {
   38778           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_toString" "', argument " "1"" of type '" "rectObj *""'"); 
   38779             :   }
   38780           1 :   arg1 = (rectObj *)(argp1);
   38781             :   {
   38782           1 :     result = (char *)rectObj_toString(arg1); {
   38783           1 :       errorObj *ms_error = msGetErrorObj();
   38784             :       
   38785           1 :       switch(ms_error->code) {
   38786             :       case MS_NOERR:
   38787             :         break;
   38788           0 :       case MS_NOTFOUND:
   38789           0 :         msResetErrorList();
   38790           0 :         break;
   38791             :       case -1:
   38792             :         break;
   38793           0 :       case MS_IOERR:
   38794           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38795           0 :           _raise_ms_exception();
   38796           0 :           msResetErrorList();
   38797           0 :           return NULL;
   38798             :         }
   38799             :       default:
   38800           0 :         _raise_ms_exception();
   38801           0 :         msResetErrorList();
   38802           0 :         return NULL;
   38803             :       }
   38804             :       
   38805             :     }
   38806             :   }
   38807           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   38808           1 :   free((char*)result);
   38809           1 :   return resultobj;
   38810           0 : fail:
   38811             :   return NULL;
   38812             : }
   38813             : 
   38814             : 
   38815           1 : SWIGINTERN PyObject *rectObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38816             :   PyObject *obj;
   38817           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   38818           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_rectObj, SWIG_NewClientData(obj));
   38819           1 :   return SWIG_Py_Void();
   38820             : }
   38821             : 
   38822           1 : SWIGINTERN PyObject *_wrap_pointObj_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38823             :   PyObject *resultobj = 0;
   38824             :   pointObj *arg1 = (pointObj *) 0 ;
   38825             :   double arg2 ;
   38826           1 :   void *argp1 = 0 ;
   38827             :   int res1 = 0 ;
   38828             :   double val2 ;
   38829             :   int ecode2 = 0 ;
   38830           1 :   PyObject * obj0 = 0 ;
   38831           1 :   PyObject * obj1 = 0 ;
   38832             :   
   38833           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_x_set",&obj0,&obj1)) SWIG_fail;
   38834           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   38835           1 :   if (!SWIG_IsOK(res1)) {
   38836           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_x_set" "', argument " "1"" of type '" "pointObj *""'"); 
   38837             :   }
   38838           1 :   arg1 = (pointObj *)(argp1);
   38839           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   38840           1 :   if (!SWIG_IsOK(ecode2)) {
   38841           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_x_set" "', argument " "2"" of type '" "double""'");
   38842             :   } 
   38843           1 :   arg2 = (double)(val2);
   38844           1 :   if (arg1) (arg1)->x = arg2;
   38845             :   resultobj = SWIG_Py_Void();
   38846           1 :   return resultobj;
   38847           0 : fail:
   38848             :   return NULL;
   38849             : }
   38850             : 
   38851             : 
   38852           1 : SWIGINTERN PyObject *_wrap_pointObj_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38853             :   PyObject *resultobj = 0;
   38854             :   pointObj *arg1 = (pointObj *) 0 ;
   38855           1 :   void *argp1 = 0 ;
   38856             :   int res1 = 0 ;
   38857           1 :   PyObject * obj0 = 0 ;
   38858             :   double result;
   38859             :   
   38860           1 :   if (!PyArg_ParseTuple(args,(char *)"O:pointObj_x_get",&obj0)) SWIG_fail;
   38861           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   38862           1 :   if (!SWIG_IsOK(res1)) {
   38863           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_x_get" "', argument " "1"" of type '" "pointObj *""'"); 
   38864             :   }
   38865           1 :   arg1 = (pointObj *)(argp1);
   38866           1 :   result = (double) ((arg1)->x);
   38867           1 :   resultobj = SWIG_From_double((double)(result));
   38868           1 :   return resultobj;
   38869           0 : fail:
   38870             :   return NULL;
   38871             : }
   38872             : 
   38873             : 
   38874           1 : SWIGINTERN PyObject *_wrap_pointObj_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38875             :   PyObject *resultobj = 0;
   38876             :   pointObj *arg1 = (pointObj *) 0 ;
   38877             :   double arg2 ;
   38878           1 :   void *argp1 = 0 ;
   38879             :   int res1 = 0 ;
   38880             :   double val2 ;
   38881             :   int ecode2 = 0 ;
   38882           1 :   PyObject * obj0 = 0 ;
   38883           1 :   PyObject * obj1 = 0 ;
   38884             :   
   38885           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_y_set",&obj0,&obj1)) SWIG_fail;
   38886           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   38887           1 :   if (!SWIG_IsOK(res1)) {
   38888           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_y_set" "', argument " "1"" of type '" "pointObj *""'"); 
   38889             :   }
   38890           1 :   arg1 = (pointObj *)(argp1);
   38891           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   38892           1 :   if (!SWIG_IsOK(ecode2)) {
   38893           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_y_set" "', argument " "2"" of type '" "double""'");
   38894             :   } 
   38895           1 :   arg2 = (double)(val2);
   38896           1 :   if (arg1) (arg1)->y = arg2;
   38897             :   resultobj = SWIG_Py_Void();
   38898           1 :   return resultobj;
   38899           0 : fail:
   38900             :   return NULL;
   38901             : }
   38902             : 
   38903             : 
   38904           1 : SWIGINTERN PyObject *_wrap_pointObj_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38905             :   PyObject *resultobj = 0;
   38906             :   pointObj *arg1 = (pointObj *) 0 ;
   38907           1 :   void *argp1 = 0 ;
   38908             :   int res1 = 0 ;
   38909           1 :   PyObject * obj0 = 0 ;
   38910             :   double result;
   38911             :   
   38912           1 :   if (!PyArg_ParseTuple(args,(char *)"O:pointObj_y_get",&obj0)) SWIG_fail;
   38913           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   38914           1 :   if (!SWIG_IsOK(res1)) {
   38915           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_y_get" "', argument " "1"" of type '" "pointObj *""'"); 
   38916             :   }
   38917           1 :   arg1 = (pointObj *)(argp1);
   38918           1 :   result = (double) ((arg1)->y);
   38919           1 :   resultobj = SWIG_From_double((double)(result));
   38920           1 :   return resultobj;
   38921           0 : fail:
   38922             :   return NULL;
   38923             : }
   38924             : 
   38925             : 
   38926           1 : SWIGINTERN PyObject *_wrap_new_pointObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   38927             :   PyObject *resultobj = 0;
   38928             :   double arg1 = (double) 0.0 ;
   38929             :   double arg2 = (double) 0.0 ;
   38930             :   double arg3 = (double) 0.0 ;
   38931             :   double arg4 = (double) -2e38 ;
   38932             :   double val1 ;
   38933             :   int ecode1 = 0 ;
   38934             :   double val2 ;
   38935             :   int ecode2 = 0 ;
   38936             :   double val3 ;
   38937             :   int ecode3 = 0 ;
   38938             :   double val4 ;
   38939             :   int ecode4 = 0 ;
   38940           1 :   PyObject * obj0 = 0 ;
   38941           1 :   PyObject * obj1 = 0 ;
   38942           1 :   PyObject * obj2 = 0 ;
   38943           1 :   PyObject * obj3 = 0 ;
   38944             :   pointObj *result = 0 ;
   38945             :   
   38946           1 :   if (!PyArg_ParseTuple(args,(char *)"|OOOO:new_pointObj",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   38947           1 :   if (obj0) {
   38948           1 :     ecode1 = SWIG_AsVal_double(obj0, &val1);
   38949           1 :     if (!SWIG_IsOK(ecode1)) {
   38950           0 :       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pointObj" "', argument " "1"" of type '" "double""'");
   38951             :     } 
   38952           1 :     arg1 = (double)(val1);
   38953             :   }
   38954           1 :   if (obj1) {
   38955           1 :     ecode2 = SWIG_AsVal_double(obj1, &val2);
   38956           1 :     if (!SWIG_IsOK(ecode2)) {
   38957           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pointObj" "', argument " "2"" of type '" "double""'");
   38958             :     } 
   38959           1 :     arg2 = (double)(val2);
   38960             :   }
   38961           1 :   if (obj2) {
   38962           1 :     ecode3 = SWIG_AsVal_double(obj2, &val3);
   38963           1 :     if (!SWIG_IsOK(ecode3)) {
   38964           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_pointObj" "', argument " "3"" of type '" "double""'");
   38965             :     } 
   38966             :     arg3 = (double)(val3);
   38967             :   }
   38968           1 :   if (obj3) {
   38969           1 :     ecode4 = SWIG_AsVal_double(obj3, &val4);
   38970           1 :     if (!SWIG_IsOK(ecode4)) {
   38971           0 :       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_pointObj" "', argument " "4"" of type '" "double""'");
   38972             :     } 
   38973             :     arg4 = (double)(val4);
   38974             :   }
   38975             :   {
   38976             :     result = (pointObj *)new_pointObj(arg1,arg2,arg3,arg4); {
   38977           1 :       errorObj *ms_error = msGetErrorObj();
   38978             :       
   38979           1 :       switch(ms_error->code) {
   38980             :       case MS_NOERR:
   38981             :         break;
   38982           0 :       case MS_NOTFOUND:
   38983           0 :         msResetErrorList();
   38984           0 :         break;
   38985             :       case -1:
   38986             :         break;
   38987           0 :       case MS_IOERR:
   38988           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   38989           0 :           _raise_ms_exception();
   38990           0 :           msResetErrorList();
   38991           0 :           return NULL;
   38992             :         }
   38993             :       default:
   38994           0 :         _raise_ms_exception();
   38995           0 :         msResetErrorList();
   38996           0 :         return NULL;
   38997             :       }
   38998             :       
   38999             :     }
   39000             :   }
   39001           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_NEW |  0 );
   39002           1 :   return resultobj;
   39003           0 : fail:
   39004             :   return NULL;
   39005             : }
   39006             : 
   39007             : 
   39008           1 : SWIGINTERN PyObject *_wrap_delete_pointObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39009             :   PyObject *resultobj = 0;
   39010             :   pointObj *arg1 = (pointObj *) 0 ;
   39011           1 :   void *argp1 = 0 ;
   39012             :   int res1 = 0 ;
   39013           1 :   PyObject * obj0 = 0 ;
   39014             :   
   39015           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_pointObj",&obj0)) SWIG_fail;
   39016           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, SWIG_POINTER_DISOWN |  0 );
   39017           1 :   if (!SWIG_IsOK(res1)) {
   39018           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pointObj" "', argument " "1"" of type '" "pointObj *""'"); 
   39019             :   }
   39020           1 :   arg1 = (pointObj *)(argp1);
   39021             :   {
   39022             :     delete_pointObj(arg1); {
   39023           1 :       errorObj *ms_error = msGetErrorObj();
   39024             :       
   39025           1 :       switch(ms_error->code) {
   39026             :       case MS_NOERR:
   39027             :         break;
   39028           0 :       case MS_NOTFOUND:
   39029           0 :         msResetErrorList();
   39030           0 :         break;
   39031             :       case -1:
   39032             :         break;
   39033           0 :       case MS_IOERR:
   39034           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39035           0 :           _raise_ms_exception();
   39036           0 :           msResetErrorList();
   39037           0 :           return NULL;
   39038             :         }
   39039             :       default:
   39040           0 :         _raise_ms_exception();
   39041           0 :         msResetErrorList();
   39042           0 :         return NULL;
   39043             :       }
   39044             :       
   39045             :     }
   39046             :   }
   39047             :   resultobj = SWIG_Py_Void();
   39048           1 :   return resultobj;
   39049           0 : fail:
   39050             :   return NULL;
   39051             : }
   39052             : 
   39053             : 
   39054           1 : SWIGINTERN PyObject *_wrap_pointObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39055             :   PyObject *resultobj = 0;
   39056             :   pointObj *arg1 = (pointObj *) 0 ;
   39057             :   projectionObj *arg2 = (projectionObj *) 0 ;
   39058             :   projectionObj *arg3 = (projectionObj *) 0 ;
   39059           1 :   void *argp1 = 0 ;
   39060             :   int res1 = 0 ;
   39061           1 :   void *argp2 = 0 ;
   39062             :   int res2 = 0 ;
   39063           1 :   void *argp3 = 0 ;
   39064             :   int res3 = 0 ;
   39065           1 :   PyObject * obj0 = 0 ;
   39066           1 :   PyObject * obj1 = 0 ;
   39067           1 :   PyObject * obj2 = 0 ;
   39068             :   int result;
   39069             :   
   39070           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:pointObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
   39071           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39072           1 :   if (!SWIG_IsOK(res1)) {
   39073           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_project" "', argument " "1"" of type '" "pointObj *""'"); 
   39074             :   }
   39075           1 :   arg1 = (pointObj *)(argp1);
   39076           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 |  0 );
   39077           1 :   if (!SWIG_IsOK(res2)) {
   39078           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_project" "', argument " "2"" of type '" "projectionObj *""'"); 
   39079             :   }
   39080           1 :   arg2 = (projectionObj *)(argp2);
   39081           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 |  0 );
   39082           1 :   if (!SWIG_IsOK(res3)) {
   39083           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pointObj_project" "', argument " "3"" of type '" "projectionObj *""'"); 
   39084             :   }
   39085           1 :   arg3 = (projectionObj *)(argp3);
   39086             :   {
   39087             :     result = (int)pointObj_project(arg1,arg2,arg3); {
   39088           1 :       errorObj *ms_error = msGetErrorObj();
   39089             :       
   39090           1 :       switch(ms_error->code) {
   39091             :       case MS_NOERR:
   39092             :         break;
   39093           0 :       case MS_NOTFOUND:
   39094           0 :         msResetErrorList();
   39095           0 :         break;
   39096             :       case -1:
   39097             :         break;
   39098           0 :       case MS_IOERR:
   39099           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39100           0 :           _raise_ms_exception();
   39101           0 :           msResetErrorList();
   39102           0 :           return NULL;
   39103             :         }
   39104             :       default:
   39105           0 :         _raise_ms_exception();
   39106           0 :         msResetErrorList();
   39107           0 :         return NULL;
   39108             :       }
   39109             :       
   39110             :     }
   39111             :   }
   39112             :   resultobj = SWIG_From_int((int)(result));
   39113           1 :   return resultobj;
   39114           0 : fail:
   39115             :   return NULL;
   39116             : }
   39117             : 
   39118             : 
   39119           1 : SWIGINTERN PyObject *_wrap_pointObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39120             :   PyObject *resultobj = 0;
   39121             :   pointObj *arg1 = (pointObj *) 0 ;
   39122             :   mapObj *arg2 = (mapObj *) 0 ;
   39123             :   layerObj *arg3 = (layerObj *) 0 ;
   39124             :   imageObj *arg4 = (imageObj *) 0 ;
   39125             :   int arg5 ;
   39126             :   char *arg6 = (char *) 0 ;
   39127           1 :   void *argp1 = 0 ;
   39128             :   int res1 = 0 ;
   39129           1 :   void *argp2 = 0 ;
   39130             :   int res2 = 0 ;
   39131           1 :   void *argp3 = 0 ;
   39132             :   int res3 = 0 ;
   39133           1 :   void *argp4 = 0 ;
   39134             :   int res4 = 0 ;
   39135             :   int val5 ;
   39136             :   int ecode5 = 0 ;
   39137             :   int res6 ;
   39138           1 :   char *buf6 = 0 ;
   39139           1 :   int alloc6 = 0 ;
   39140           1 :   PyObject * obj0 = 0 ;
   39141           1 :   PyObject * obj1 = 0 ;
   39142           1 :   PyObject * obj2 = 0 ;
   39143           1 :   PyObject * obj3 = 0 ;
   39144           1 :   PyObject * obj4 = 0 ;
   39145           1 :   PyObject * obj5 = 0 ;
   39146             :   int result;
   39147             :   
   39148           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:pointObj_draw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   39149           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39150           1 :   if (!SWIG_IsOK(res1)) {
   39151           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_draw" "', argument " "1"" of type '" "pointObj *""'"); 
   39152             :   }
   39153           1 :   arg1 = (pointObj *)(argp1);
   39154           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   39155           1 :   if (!SWIG_IsOK(res2)) {
   39156           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_draw" "', argument " "2"" of type '" "mapObj *""'"); 
   39157             :   }
   39158           1 :   arg2 = (mapObj *)(argp2);
   39159           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 |  0 );
   39160           1 :   if (!SWIG_IsOK(res3)) {
   39161           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pointObj_draw" "', argument " "3"" of type '" "layerObj *""'"); 
   39162             :   }
   39163           1 :   arg3 = (layerObj *)(argp3);
   39164           1 :   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_imageObj, 0 |  0 );
   39165           1 :   if (!SWIG_IsOK(res4)) {
   39166           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pointObj_draw" "', argument " "4"" of type '" "imageObj *""'"); 
   39167             :   }
   39168           1 :   arg4 = (imageObj *)(argp4);
   39169           1 :   ecode5 = SWIG_AsVal_int(obj4, &val5);
   39170           1 :   if (!SWIG_IsOK(ecode5)) {
   39171           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pointObj_draw" "', argument " "5"" of type '" "int""'");
   39172             :   } 
   39173             :   arg5 = (int)(val5);
   39174           1 :   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
   39175           1 :   if (!SWIG_IsOK(res6)) {
   39176           0 :     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "pointObj_draw" "', argument " "6"" of type '" "char *""'");
   39177             :   }
   39178           1 :   arg6 = (char *)(buf6);
   39179             :   {
   39180             :     result = (int)pointObj_draw(arg1,arg2,arg3,arg4,arg5,arg6); {
   39181           1 :       errorObj *ms_error = msGetErrorObj();
   39182             :       
   39183           1 :       switch(ms_error->code) {
   39184             :       case MS_NOERR:
   39185             :         break;
   39186           0 :       case MS_NOTFOUND:
   39187           0 :         msResetErrorList();
   39188           0 :         break;
   39189             :       case -1:
   39190             :         break;
   39191           0 :       case MS_IOERR:
   39192           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39193           0 :           _raise_ms_exception();
   39194           0 :           msResetErrorList();
   39195           0 :           return NULL;
   39196             :         }
   39197             :       default:
   39198           0 :         _raise_ms_exception();
   39199           0 :         msResetErrorList();
   39200           0 :         return NULL;
   39201             :       }
   39202             :       
   39203             :     }
   39204             :   }
   39205             :   resultobj = SWIG_From_int((int)(result));
   39206           1 :   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
   39207             :   return resultobj;
   39208           0 : fail:
   39209           0 :   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
   39210             :   return NULL;
   39211             : }
   39212             : 
   39213             : 
   39214           0 : SWIGINTERN PyObject *_wrap_pointObj_distanceToPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39215             :   PyObject *resultobj = 0;
   39216             :   pointObj *arg1 = (pointObj *) 0 ;
   39217             :   pointObj *arg2 = (pointObj *) 0 ;
   39218           0 :   void *argp1 = 0 ;
   39219             :   int res1 = 0 ;
   39220           0 :   void *argp2 = 0 ;
   39221             :   int res2 = 0 ;
   39222           0 :   PyObject * obj0 = 0 ;
   39223           0 :   PyObject * obj1 = 0 ;
   39224             :   double result;
   39225             :   
   39226           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_distanceToPoint",&obj0,&obj1)) SWIG_fail;
   39227           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39228           0 :   if (!SWIG_IsOK(res1)) {
   39229           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_distanceToPoint" "', argument " "1"" of type '" "pointObj *""'"); 
   39230             :   }
   39231           0 :   arg1 = (pointObj *)(argp1);
   39232           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   39233           0 :   if (!SWIG_IsOK(res2)) {
   39234           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_distanceToPoint" "', argument " "2"" of type '" "pointObj *""'"); 
   39235             :   }
   39236           0 :   arg2 = (pointObj *)(argp2);
   39237             :   {
   39238             :     result = (double)pointObj_distanceToPoint(arg1,arg2); {
   39239           0 :       errorObj *ms_error = msGetErrorObj();
   39240             :       
   39241           0 :       switch(ms_error->code) {
   39242             :       case MS_NOERR:
   39243             :         break;
   39244           0 :       case MS_NOTFOUND:
   39245           0 :         msResetErrorList();
   39246           0 :         break;
   39247             :       case -1:
   39248             :         break;
   39249           0 :       case MS_IOERR:
   39250           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39251           0 :           _raise_ms_exception();
   39252           0 :           msResetErrorList();
   39253           0 :           return NULL;
   39254             :         }
   39255             :       default:
   39256           0 :         _raise_ms_exception();
   39257           0 :         msResetErrorList();
   39258           0 :         return NULL;
   39259             :       }
   39260             :       
   39261             :     }
   39262             :   }
   39263           0 :   resultobj = SWIG_From_double((double)(result));
   39264           0 :   return resultobj;
   39265           0 : fail:
   39266             :   return NULL;
   39267             : }
   39268             : 
   39269             : 
   39270           0 : SWIGINTERN PyObject *_wrap_pointObj_distanceToSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39271             :   PyObject *resultobj = 0;
   39272             :   pointObj *arg1 = (pointObj *) 0 ;
   39273             :   pointObj *arg2 = (pointObj *) 0 ;
   39274             :   pointObj *arg3 = (pointObj *) 0 ;
   39275           0 :   void *argp1 = 0 ;
   39276             :   int res1 = 0 ;
   39277           0 :   void *argp2 = 0 ;
   39278             :   int res2 = 0 ;
   39279           0 :   void *argp3 = 0 ;
   39280             :   int res3 = 0 ;
   39281           0 :   PyObject * obj0 = 0 ;
   39282           0 :   PyObject * obj1 = 0 ;
   39283           0 :   PyObject * obj2 = 0 ;
   39284             :   double result;
   39285             :   
   39286           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:pointObj_distanceToSegment",&obj0,&obj1,&obj2)) SWIG_fail;
   39287           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39288           0 :   if (!SWIG_IsOK(res1)) {
   39289           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_distanceToSegment" "', argument " "1"" of type '" "pointObj *""'"); 
   39290             :   }
   39291           0 :   arg1 = (pointObj *)(argp1);
   39292           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   39293           0 :   if (!SWIG_IsOK(res2)) {
   39294           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_distanceToSegment" "', argument " "2"" of type '" "pointObj *""'"); 
   39295             :   }
   39296           0 :   arg2 = (pointObj *)(argp2);
   39297           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 |  0 );
   39298           0 :   if (!SWIG_IsOK(res3)) {
   39299           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pointObj_distanceToSegment" "', argument " "3"" of type '" "pointObj *""'"); 
   39300             :   }
   39301           0 :   arg3 = (pointObj *)(argp3);
   39302             :   {
   39303             :     result = (double)pointObj_distanceToSegment(arg1,arg2,arg3); {
   39304           0 :       errorObj *ms_error = msGetErrorObj();
   39305             :       
   39306           0 :       switch(ms_error->code) {
   39307             :       case MS_NOERR:
   39308             :         break;
   39309           0 :       case MS_NOTFOUND:
   39310           0 :         msResetErrorList();
   39311           0 :         break;
   39312             :       case -1:
   39313             :         break;
   39314           0 :       case MS_IOERR:
   39315           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39316           0 :           _raise_ms_exception();
   39317           0 :           msResetErrorList();
   39318           0 :           return NULL;
   39319             :         }
   39320             :       default:
   39321           0 :         _raise_ms_exception();
   39322           0 :         msResetErrorList();
   39323           0 :         return NULL;
   39324             :       }
   39325             :       
   39326             :     }
   39327             :   }
   39328           0 :   resultobj = SWIG_From_double((double)(result));
   39329           0 :   return resultobj;
   39330           0 : fail:
   39331             :   return NULL;
   39332             : }
   39333             : 
   39334             : 
   39335           0 : SWIGINTERN PyObject *_wrap_pointObj_distanceToShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39336             :   PyObject *resultobj = 0;
   39337             :   pointObj *arg1 = (pointObj *) 0 ;
   39338             :   shapeObj *arg2 = (shapeObj *) 0 ;
   39339           0 :   void *argp1 = 0 ;
   39340             :   int res1 = 0 ;
   39341           0 :   void *argp2 = 0 ;
   39342             :   int res2 = 0 ;
   39343           0 :   PyObject * obj0 = 0 ;
   39344           0 :   PyObject * obj1 = 0 ;
   39345             :   double result;
   39346             :   
   39347           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_distanceToShape",&obj0,&obj1)) SWIG_fail;
   39348           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39349           0 :   if (!SWIG_IsOK(res1)) {
   39350           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_distanceToShape" "', argument " "1"" of type '" "pointObj *""'"); 
   39351             :   }
   39352           0 :   arg1 = (pointObj *)(argp1);
   39353           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   39354           0 :   if (!SWIG_IsOK(res2)) {
   39355           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_distanceToShape" "', argument " "2"" of type '" "shapeObj *""'"); 
   39356             :   }
   39357           0 :   arg2 = (shapeObj *)(argp2);
   39358             :   {
   39359             :     result = (double)pointObj_distanceToShape(arg1,arg2); {
   39360           0 :       errorObj *ms_error = msGetErrorObj();
   39361             :       
   39362           0 :       switch(ms_error->code) {
   39363             :       case MS_NOERR:
   39364             :         break;
   39365           0 :       case MS_NOTFOUND:
   39366           0 :         msResetErrorList();
   39367           0 :         break;
   39368             :       case -1:
   39369             :         break;
   39370           0 :       case MS_IOERR:
   39371           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39372           0 :           _raise_ms_exception();
   39373           0 :           msResetErrorList();
   39374           0 :           return NULL;
   39375             :         }
   39376             :       default:
   39377           0 :         _raise_ms_exception();
   39378           0 :         msResetErrorList();
   39379           0 :         return NULL;
   39380             :       }
   39381             :       
   39382             :     }
   39383             :   }
   39384           0 :   resultobj = SWIG_From_double((double)(result));
   39385           0 :   return resultobj;
   39386           0 : fail:
   39387             :   return NULL;
   39388             : }
   39389             : 
   39390             : 
   39391           1 : SWIGINTERN PyObject *_wrap_pointObj_setXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39392             :   PyObject *resultobj = 0;
   39393             :   pointObj *arg1 = (pointObj *) 0 ;
   39394             :   double arg2 ;
   39395             :   double arg3 ;
   39396             :   double arg4 = (double) -2e38 ;
   39397           1 :   void *argp1 = 0 ;
   39398             :   int res1 = 0 ;
   39399             :   double val2 ;
   39400             :   int ecode2 = 0 ;
   39401             :   double val3 ;
   39402             :   int ecode3 = 0 ;
   39403             :   double val4 ;
   39404             :   int ecode4 = 0 ;
   39405           1 :   PyObject * obj0 = 0 ;
   39406           1 :   PyObject * obj1 = 0 ;
   39407           1 :   PyObject * obj2 = 0 ;
   39408           1 :   PyObject * obj3 = 0 ;
   39409             :   int result;
   39410             :   
   39411           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO|O:pointObj_setXY",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   39412           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39413           1 :   if (!SWIG_IsOK(res1)) {
   39414           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_setXY" "', argument " "1"" of type '" "pointObj *""'"); 
   39415             :   }
   39416           1 :   arg1 = (pointObj *)(argp1);
   39417           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   39418           1 :   if (!SWIG_IsOK(ecode2)) {
   39419           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_setXY" "', argument " "2"" of type '" "double""'");
   39420             :   } 
   39421           1 :   arg2 = (double)(val2);
   39422           1 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   39423           1 :   if (!SWIG_IsOK(ecode3)) {
   39424           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pointObj_setXY" "', argument " "3"" of type '" "double""'");
   39425             :   } 
   39426           1 :   arg3 = (double)(val3);
   39427           1 :   if (obj3) {
   39428           1 :     ecode4 = SWIG_AsVal_double(obj3, &val4);
   39429           1 :     if (!SWIG_IsOK(ecode4)) {
   39430           0 :       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pointObj_setXY" "', argument " "4"" of type '" "double""'");
   39431             :     } 
   39432             :     arg4 = (double)(val4);
   39433             :   }
   39434             :   {
   39435             :     result = (int)pointObj_setXY(arg1,arg2,arg3,arg4); {
   39436           1 :       errorObj *ms_error = msGetErrorObj();
   39437             :       
   39438           1 :       switch(ms_error->code) {
   39439             :       case MS_NOERR:
   39440             :         break;
   39441           0 :       case MS_NOTFOUND:
   39442           0 :         msResetErrorList();
   39443           0 :         break;
   39444             :       case -1:
   39445             :         break;
   39446           0 :       case MS_IOERR:
   39447           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39448           0 :           _raise_ms_exception();
   39449           0 :           msResetErrorList();
   39450           0 :           return NULL;
   39451             :         }
   39452             :       default:
   39453           0 :         _raise_ms_exception();
   39454           0 :         msResetErrorList();
   39455           0 :         return NULL;
   39456             :       }
   39457             :       
   39458             :     }
   39459             :   }
   39460             :   resultobj = SWIG_From_int((int)(result));
   39461           1 :   return resultobj;
   39462           0 : fail:
   39463             :   return NULL;
   39464             : }
   39465             : 
   39466             : 
   39467           1 : SWIGINTERN PyObject *_wrap_pointObj_setXYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39468             :   PyObject *resultobj = 0;
   39469             :   pointObj *arg1 = (pointObj *) 0 ;
   39470             :   double arg2 ;
   39471             :   double arg3 ;
   39472             :   double arg4 ;
   39473             :   double arg5 = (double) -2e38 ;
   39474           1 :   void *argp1 = 0 ;
   39475             :   int res1 = 0 ;
   39476             :   double val2 ;
   39477             :   int ecode2 = 0 ;
   39478             :   double val3 ;
   39479             :   int ecode3 = 0 ;
   39480             :   double val4 ;
   39481             :   int ecode4 = 0 ;
   39482             :   double val5 ;
   39483             :   int ecode5 = 0 ;
   39484           1 :   PyObject * obj0 = 0 ;
   39485           1 :   PyObject * obj1 = 0 ;
   39486           1 :   PyObject * obj2 = 0 ;
   39487           1 :   PyObject * obj3 = 0 ;
   39488           1 :   PyObject * obj4 = 0 ;
   39489             :   int result;
   39490             :   
   39491           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOO|O:pointObj_setXYZ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   39492           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39493           1 :   if (!SWIG_IsOK(res1)) {
   39494           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_setXYZ" "', argument " "1"" of type '" "pointObj *""'"); 
   39495             :   }
   39496           1 :   arg1 = (pointObj *)(argp1);
   39497           1 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   39498           1 :   if (!SWIG_IsOK(ecode2)) {
   39499           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_setXYZ" "', argument " "2"" of type '" "double""'");
   39500             :   } 
   39501           1 :   arg2 = (double)(val2);
   39502           1 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   39503           1 :   if (!SWIG_IsOK(ecode3)) {
   39504           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pointObj_setXYZ" "', argument " "3"" of type '" "double""'");
   39505             :   } 
   39506           1 :   arg3 = (double)(val3);
   39507           1 :   ecode4 = SWIG_AsVal_double(obj3, &val4);
   39508           1 :   if (!SWIG_IsOK(ecode4)) {
   39509           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pointObj_setXYZ" "', argument " "4"" of type '" "double""'");
   39510             :   } 
   39511             :   arg4 = (double)(val4);
   39512           1 :   if (obj4) {
   39513           1 :     ecode5 = SWIG_AsVal_double(obj4, &val5);
   39514           1 :     if (!SWIG_IsOK(ecode5)) {
   39515           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pointObj_setXYZ" "', argument " "5"" of type '" "double""'");
   39516             :     } 
   39517             :     arg5 = (double)(val5);
   39518             :   }
   39519             :   {
   39520             :     result = (int)pointObj_setXYZ(arg1,arg2,arg3,arg4,arg5); {
   39521           1 :       errorObj *ms_error = msGetErrorObj();
   39522             :       
   39523           1 :       switch(ms_error->code) {
   39524             :       case MS_NOERR:
   39525             :         break;
   39526           0 :       case MS_NOTFOUND:
   39527           0 :         msResetErrorList();
   39528           0 :         break;
   39529             :       case -1:
   39530             :         break;
   39531           0 :       case MS_IOERR:
   39532           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39533           0 :           _raise_ms_exception();
   39534           0 :           msResetErrorList();
   39535           0 :           return NULL;
   39536             :         }
   39537             :       default:
   39538           0 :         _raise_ms_exception();
   39539           0 :         msResetErrorList();
   39540           0 :         return NULL;
   39541             :       }
   39542             :       
   39543             :     }
   39544             :   }
   39545             :   resultobj = SWIG_From_int((int)(result));
   39546           1 :   return resultobj;
   39547           0 : fail:
   39548             :   return NULL;
   39549             : }
   39550             : 
   39551             : 
   39552           0 : SWIGINTERN PyObject *_wrap_pointObj_setXYZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39553             :   PyObject *resultobj = 0;
   39554             :   pointObj *arg1 = (pointObj *) 0 ;
   39555             :   double arg2 ;
   39556             :   double arg3 ;
   39557             :   double arg4 ;
   39558             :   double arg5 ;
   39559           0 :   void *argp1 = 0 ;
   39560             :   int res1 = 0 ;
   39561             :   double val2 ;
   39562             :   int ecode2 = 0 ;
   39563             :   double val3 ;
   39564             :   int ecode3 = 0 ;
   39565             :   double val4 ;
   39566             :   int ecode4 = 0 ;
   39567             :   double val5 ;
   39568             :   int ecode5 = 0 ;
   39569           0 :   PyObject * obj0 = 0 ;
   39570           0 :   PyObject * obj1 = 0 ;
   39571           0 :   PyObject * obj2 = 0 ;
   39572           0 :   PyObject * obj3 = 0 ;
   39573           0 :   PyObject * obj4 = 0 ;
   39574             :   int result;
   39575             :   
   39576           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:pointObj_setXYZM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   39577           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39578           0 :   if (!SWIG_IsOK(res1)) {
   39579           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_setXYZM" "', argument " "1"" of type '" "pointObj *""'"); 
   39580             :   }
   39581           0 :   arg1 = (pointObj *)(argp1);
   39582           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   39583           0 :   if (!SWIG_IsOK(ecode2)) {
   39584           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_setXYZM" "', argument " "2"" of type '" "double""'");
   39585             :   } 
   39586           0 :   arg2 = (double)(val2);
   39587           0 :   ecode3 = SWIG_AsVal_double(obj2, &val3);
   39588           0 :   if (!SWIG_IsOK(ecode3)) {
   39589           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pointObj_setXYZM" "', argument " "3"" of type '" "double""'");
   39590             :   } 
   39591           0 :   arg3 = (double)(val3);
   39592           0 :   ecode4 = SWIG_AsVal_double(obj3, &val4);
   39593           0 :   if (!SWIG_IsOK(ecode4)) {
   39594           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pointObj_setXYZM" "', argument " "4"" of type '" "double""'");
   39595             :   } 
   39596             :   arg4 = (double)(val4);
   39597           0 :   ecode5 = SWIG_AsVal_double(obj4, &val5);
   39598           0 :   if (!SWIG_IsOK(ecode5)) {
   39599           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pointObj_setXYZM" "', argument " "5"" of type '" "double""'");
   39600             :   } 
   39601             :   arg5 = (double)(val5);
   39602             :   {
   39603             :     result = (int)pointObj_setXYZM(arg1,arg2,arg3,arg4,arg5); {
   39604           0 :       errorObj *ms_error = msGetErrorObj();
   39605             :       
   39606           0 :       switch(ms_error->code) {
   39607             :       case MS_NOERR:
   39608             :         break;
   39609           0 :       case MS_NOTFOUND:
   39610           0 :         msResetErrorList();
   39611           0 :         break;
   39612             :       case -1:
   39613             :         break;
   39614           0 :       case MS_IOERR:
   39615           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39616           0 :           _raise_ms_exception();
   39617           0 :           msResetErrorList();
   39618           0 :           return NULL;
   39619             :         }
   39620             :       default:
   39621           0 :         _raise_ms_exception();
   39622           0 :         msResetErrorList();
   39623           0 :         return NULL;
   39624             :       }
   39625             :       
   39626             :     }
   39627             :   }
   39628             :   resultobj = SWIG_From_int((int)(result));
   39629           0 :   return resultobj;
   39630           0 : fail:
   39631             :   return NULL;
   39632             : }
   39633             : 
   39634             : 
   39635           1 : SWIGINTERN PyObject *_wrap_pointObj_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39636             :   PyObject *resultobj = 0;
   39637             :   pointObj *arg1 = (pointObj *) 0 ;
   39638           1 :   void *argp1 = 0 ;
   39639             :   int res1 = 0 ;
   39640           1 :   PyObject * obj0 = 0 ;
   39641             :   char *result = 0 ;
   39642             :   
   39643           1 :   if (!PyArg_ParseTuple(args,(char *)"O:pointObj_toString",&obj0)) SWIG_fail;
   39644           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39645           1 :   if (!SWIG_IsOK(res1)) {
   39646           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_toString" "', argument " "1"" of type '" "pointObj *""'"); 
   39647             :   }
   39648           1 :   arg1 = (pointObj *)(argp1);
   39649             :   {
   39650           1 :     result = (char *)pointObj_toString(arg1); {
   39651           1 :       errorObj *ms_error = msGetErrorObj();
   39652             :       
   39653           1 :       switch(ms_error->code) {
   39654             :       case MS_NOERR:
   39655             :         break;
   39656           0 :       case MS_NOTFOUND:
   39657           0 :         msResetErrorList();
   39658           0 :         break;
   39659             :       case -1:
   39660             :         break;
   39661           0 :       case MS_IOERR:
   39662           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39663           0 :           _raise_ms_exception();
   39664           0 :           msResetErrorList();
   39665           0 :           return NULL;
   39666             :         }
   39667             :       default:
   39668           0 :         _raise_ms_exception();
   39669           0 :         msResetErrorList();
   39670           0 :         return NULL;
   39671             :       }
   39672             :       
   39673             :     }
   39674             :   }
   39675           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   39676           1 :   free((char*)result);
   39677           1 :   return resultobj;
   39678           0 : fail:
   39679             :   return NULL;
   39680             : }
   39681             : 
   39682             : 
   39683           0 : SWIGINTERN PyObject *_wrap_pointObj_toShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39684             :   PyObject *resultobj = 0;
   39685             :   pointObj *arg1 = (pointObj *) 0 ;
   39686           0 :   void *argp1 = 0 ;
   39687             :   int res1 = 0 ;
   39688           0 :   PyObject * obj0 = 0 ;
   39689             :   shapeObj *result = 0 ;
   39690             :   
   39691           0 :   if (!PyArg_ParseTuple(args,(char *)"O:pointObj_toShape",&obj0)) SWIG_fail;
   39692           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 |  0 );
   39693           0 :   if (!SWIG_IsOK(res1)) {
   39694           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_toShape" "', argument " "1"" of type '" "pointObj *""'"); 
   39695             :   }
   39696           0 :   arg1 = (pointObj *)(argp1);
   39697             :   {
   39698           0 :     result = (shapeObj *)pointObj_toShape(arg1); {
   39699           0 :       errorObj *ms_error = msGetErrorObj();
   39700             :       
   39701           0 :       switch(ms_error->code) {
   39702             :       case MS_NOERR:
   39703             :         break;
   39704           0 :       case MS_NOTFOUND:
   39705           0 :         msResetErrorList();
   39706           0 :         break;
   39707             :       case -1:
   39708             :         break;
   39709           0 :       case MS_IOERR:
   39710           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39711           0 :           _raise_ms_exception();
   39712           0 :           msResetErrorList();
   39713           0 :           return NULL;
   39714             :         }
   39715             :       default:
   39716           0 :         _raise_ms_exception();
   39717           0 :         msResetErrorList();
   39718           0 :         return NULL;
   39719             :       }
   39720             :       
   39721             :     }
   39722             :   }
   39723           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   39724           0 :   return resultobj;
   39725           0 : fail:
   39726             :   return NULL;
   39727             : }
   39728             : 
   39729             : 
   39730           1 : SWIGINTERN PyObject *pointObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39731             :   PyObject *obj;
   39732           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   39733           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_pointObj, SWIG_NewClientData(obj));
   39734           1 :   return SWIG_Py_Void();
   39735             : }
   39736             : 
   39737           1 : SWIGINTERN PyObject *_wrap_lineObj_numpoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39738             :   PyObject *resultobj = 0;
   39739             :   lineObj *arg1 = (lineObj *) 0 ;
   39740           1 :   void *argp1 = 0 ;
   39741             :   int res1 = 0 ;
   39742           1 :   PyObject * obj0 = 0 ;
   39743             :   int result;
   39744             :   
   39745           1 :   if (!PyArg_ParseTuple(args,(char *)"O:lineObj_numpoints_get",&obj0)) SWIG_fail;
   39746           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 |  0 );
   39747           1 :   if (!SWIG_IsOK(res1)) {
   39748           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_numpoints_get" "', argument " "1"" of type '" "lineObj *""'"); 
   39749             :   }
   39750           1 :   arg1 = (lineObj *)(argp1);
   39751           1 :   result = (int) ((arg1)->numpoints);
   39752             :   resultobj = SWIG_From_int((int)(result));
   39753           1 :   return resultobj;
   39754           0 : fail:
   39755             :   return NULL;
   39756             : }
   39757             : 
   39758             : 
   39759           1 : SWIGINTERN PyObject *_wrap_new_lineObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39760             :   PyObject *resultobj = 0;
   39761             :   lineObj *result = 0 ;
   39762             :   
   39763           1 :   if (!PyArg_ParseTuple(args,(char *)":new_lineObj")) SWIG_fail;
   39764             :   {
   39765             :     result = (lineObj *)new_lineObj(); {
   39766           1 :       errorObj *ms_error = msGetErrorObj();
   39767             :       
   39768           1 :       switch(ms_error->code) {
   39769             :       case MS_NOERR:
   39770             :         break;
   39771           0 :       case MS_NOTFOUND:
   39772           0 :         msResetErrorList();
   39773           0 :         break;
   39774             :       case -1:
   39775             :         break;
   39776           0 :       case MS_IOERR:
   39777           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39778           0 :           _raise_ms_exception();
   39779           0 :           msResetErrorList();
   39780           0 :           return NULL;
   39781             :         }
   39782             :       default:
   39783           0 :         _raise_ms_exception();
   39784           0 :         msResetErrorList();
   39785           0 :         return NULL;
   39786             :       }
   39787             :       
   39788             :     }
   39789             :   }
   39790           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, SWIG_POINTER_NEW |  0 );
   39791           1 :   return resultobj;
   39792           1 : fail:
   39793             :   return NULL;
   39794             : }
   39795             : 
   39796             : 
   39797           1 : SWIGINTERN PyObject *_wrap_delete_lineObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39798             :   PyObject *resultobj = 0;
   39799             :   lineObj *arg1 = (lineObj *) 0 ;
   39800           1 :   void *argp1 = 0 ;
   39801             :   int res1 = 0 ;
   39802           1 :   PyObject * obj0 = 0 ;
   39803             :   
   39804           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_lineObj",&obj0)) SWIG_fail;
   39805           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, SWIG_POINTER_DISOWN |  0 );
   39806           1 :   if (!SWIG_IsOK(res1)) {
   39807           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_lineObj" "', argument " "1"" of type '" "lineObj *""'"); 
   39808             :   }
   39809           1 :   arg1 = (lineObj *)(argp1);
   39810             :   {
   39811             :     delete_lineObj(arg1); {
   39812           1 :       errorObj *ms_error = msGetErrorObj();
   39813             :       
   39814           1 :       switch(ms_error->code) {
   39815             :       case MS_NOERR:
   39816             :         break;
   39817           0 :       case MS_NOTFOUND:
   39818           0 :         msResetErrorList();
   39819           0 :         break;
   39820             :       case -1:
   39821             :         break;
   39822           0 :       case MS_IOERR:
   39823           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39824           0 :           _raise_ms_exception();
   39825           0 :           msResetErrorList();
   39826           0 :           return NULL;
   39827             :         }
   39828             :       default:
   39829           0 :         _raise_ms_exception();
   39830           0 :         msResetErrorList();
   39831           0 :         return NULL;
   39832             :       }
   39833             :       
   39834             :     }
   39835             :   }
   39836             :   resultobj = SWIG_Py_Void();
   39837           1 :   return resultobj;
   39838           0 : fail:
   39839             :   return NULL;
   39840             : }
   39841             : 
   39842             : 
   39843           0 : SWIGINTERN PyObject *_wrap_lineObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39844             :   PyObject *resultobj = 0;
   39845             :   lineObj *arg1 = (lineObj *) 0 ;
   39846             :   projectionObj *arg2 = (projectionObj *) 0 ;
   39847             :   projectionObj *arg3 = (projectionObj *) 0 ;
   39848           0 :   void *argp1 = 0 ;
   39849             :   int res1 = 0 ;
   39850           0 :   void *argp2 = 0 ;
   39851             :   int res2 = 0 ;
   39852           0 :   void *argp3 = 0 ;
   39853             :   int res3 = 0 ;
   39854           0 :   PyObject * obj0 = 0 ;
   39855           0 :   PyObject * obj1 = 0 ;
   39856           0 :   PyObject * obj2 = 0 ;
   39857             :   int result;
   39858             :   
   39859           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:lineObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
   39860           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 |  0 );
   39861           0 :   if (!SWIG_IsOK(res1)) {
   39862           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_project" "', argument " "1"" of type '" "lineObj *""'"); 
   39863             :   }
   39864           0 :   arg1 = (lineObj *)(argp1);
   39865           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 |  0 );
   39866           0 :   if (!SWIG_IsOK(res2)) {
   39867           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lineObj_project" "', argument " "2"" of type '" "projectionObj *""'"); 
   39868             :   }
   39869           0 :   arg2 = (projectionObj *)(argp2);
   39870           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 |  0 );
   39871           0 :   if (!SWIG_IsOK(res3)) {
   39872           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lineObj_project" "', argument " "3"" of type '" "projectionObj *""'"); 
   39873             :   }
   39874           0 :   arg3 = (projectionObj *)(argp3);
   39875             :   {
   39876             :     result = (int)lineObj_project(arg1,arg2,arg3); {
   39877           0 :       errorObj *ms_error = msGetErrorObj();
   39878             :       
   39879           0 :       switch(ms_error->code) {
   39880             :       case MS_NOERR:
   39881             :         break;
   39882           0 :       case MS_NOTFOUND:
   39883           0 :         msResetErrorList();
   39884           0 :         break;
   39885             :       case -1:
   39886             :         break;
   39887           0 :       case MS_IOERR:
   39888           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39889           0 :           _raise_ms_exception();
   39890           0 :           msResetErrorList();
   39891           0 :           return NULL;
   39892             :         }
   39893             :       default:
   39894           0 :         _raise_ms_exception();
   39895           0 :         msResetErrorList();
   39896           0 :         return NULL;
   39897             :       }
   39898             :       
   39899             :     }
   39900             :   }
   39901             :   resultobj = SWIG_From_int((int)(result));
   39902           0 :   return resultobj;
   39903           0 : fail:
   39904             :   return NULL;
   39905             : }
   39906             : 
   39907             : 
   39908           1 : SWIGINTERN PyObject *_wrap_lineObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39909             :   PyObject *resultobj = 0;
   39910             :   lineObj *arg1 = (lineObj *) 0 ;
   39911             :   int arg2 ;
   39912           1 :   void *argp1 = 0 ;
   39913             :   int res1 = 0 ;
   39914             :   int val2 ;
   39915             :   int ecode2 = 0 ;
   39916           1 :   PyObject * obj0 = 0 ;
   39917           1 :   PyObject * obj1 = 0 ;
   39918             :   pointObj *result = 0 ;
   39919             :   
   39920           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:lineObj_get",&obj0,&obj1)) SWIG_fail;
   39921           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 |  0 );
   39922           1 :   if (!SWIG_IsOK(res1)) {
   39923           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_get" "', argument " "1"" of type '" "lineObj *""'"); 
   39924             :   }
   39925           1 :   arg1 = (lineObj *)(argp1);
   39926           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   39927           1 :   if (!SWIG_IsOK(ecode2)) {
   39928           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lineObj_get" "', argument " "2"" of type '" "int""'");
   39929             :   } 
   39930             :   arg2 = (int)(val2);
   39931             :   {
   39932             :     result = (pointObj *)lineObj_get(arg1,arg2); {
   39933           1 :       errorObj *ms_error = msGetErrorObj();
   39934             :       
   39935           1 :       switch(ms_error->code) {
   39936             :       case MS_NOERR:
   39937             :         break;
   39938           0 :       case MS_NOTFOUND:
   39939           0 :         msResetErrorList();
   39940           0 :         break;
   39941             :       case -1:
   39942             :         break;
   39943           0 :       case MS_IOERR:
   39944           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   39945           0 :           _raise_ms_exception();
   39946           0 :           msResetErrorList();
   39947           0 :           return NULL;
   39948             :         }
   39949             :       default:
   39950           0 :         _raise_ms_exception();
   39951           0 :         msResetErrorList();
   39952           0 :         return NULL;
   39953             :       }
   39954             :       
   39955             :     }
   39956             :   }
   39957           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, 0 |  0 );
   39958           1 :   return resultobj;
   39959           0 : fail:
   39960             :   return NULL;
   39961             : }
   39962             : 
   39963             : 
   39964           1 : SWIGINTERN PyObject *_wrap_lineObj_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   39965             :   PyObject *resultobj = 0;
   39966             :   lineObj *arg1 = (lineObj *) 0 ;
   39967             :   pointObj *arg2 = (pointObj *) 0 ;
   39968           1 :   void *argp1 = 0 ;
   39969             :   int res1 = 0 ;
   39970           1 :   void *argp2 = 0 ;
   39971             :   int res2 = 0 ;
   39972           1 :   PyObject * obj0 = 0 ;
   39973           1 :   PyObject * obj1 = 0 ;
   39974             :   int result;
   39975             :   
   39976           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:lineObj_add",&obj0,&obj1)) SWIG_fail;
   39977           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 |  0 );
   39978           1 :   if (!SWIG_IsOK(res1)) {
   39979           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_add" "', argument " "1"" of type '" "lineObj *""'"); 
   39980             :   }
   39981           1 :   arg1 = (lineObj *)(argp1);
   39982           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   39983           1 :   if (!SWIG_IsOK(res2)) {
   39984           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lineObj_add" "', argument " "2"" of type '" "pointObj *""'"); 
   39985             :   }
   39986           1 :   arg2 = (pointObj *)(argp2);
   39987             :   {
   39988           1 :     result = (int)lineObj_add(arg1,arg2); {
   39989           1 :       errorObj *ms_error = msGetErrorObj();
   39990             :       
   39991           1 :       switch(ms_error->code) {
   39992             :       case MS_NOERR:
   39993             :         break;
   39994           0 :       case MS_NOTFOUND:
   39995           0 :         msResetErrorList();
   39996           0 :         break;
   39997             :       case -1:
   39998             :         break;
   39999           0 :       case MS_IOERR:
   40000           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40001           0 :           _raise_ms_exception();
   40002           0 :           msResetErrorList();
   40003           0 :           return NULL;
   40004             :         }
   40005             :       default:
   40006           0 :         _raise_ms_exception();
   40007           0 :         msResetErrorList();
   40008           0 :         return NULL;
   40009             :       }
   40010             :       
   40011             :     }
   40012             :   }
   40013             :   resultobj = SWIG_From_int((int)(result));
   40014           1 :   return resultobj;
   40015           0 : fail:
   40016             :   return NULL;
   40017             : }
   40018             : 
   40019             : 
   40020           0 : SWIGINTERN PyObject *_wrap_lineObj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40021             :   PyObject *resultobj = 0;
   40022             :   lineObj *arg1 = (lineObj *) 0 ;
   40023             :   int arg2 ;
   40024             :   pointObj *arg3 = (pointObj *) 0 ;
   40025           0 :   void *argp1 = 0 ;
   40026             :   int res1 = 0 ;
   40027             :   int val2 ;
   40028             :   int ecode2 = 0 ;
   40029           0 :   void *argp3 = 0 ;
   40030             :   int res3 = 0 ;
   40031           0 :   PyObject * obj0 = 0 ;
   40032           0 :   PyObject * obj1 = 0 ;
   40033           0 :   PyObject * obj2 = 0 ;
   40034             :   int result;
   40035             :   
   40036           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:lineObj_set",&obj0,&obj1,&obj2)) SWIG_fail;
   40037           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 |  0 );
   40038           0 :   if (!SWIG_IsOK(res1)) {
   40039           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_set" "', argument " "1"" of type '" "lineObj *""'"); 
   40040             :   }
   40041           0 :   arg1 = (lineObj *)(argp1);
   40042           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40043           0 :   if (!SWIG_IsOK(ecode2)) {
   40044           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lineObj_set" "', argument " "2"" of type '" "int""'");
   40045             :   } 
   40046             :   arg2 = (int)(val2);
   40047           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 |  0 );
   40048           0 :   if (!SWIG_IsOK(res3)) {
   40049           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lineObj_set" "', argument " "3"" of type '" "pointObj *""'"); 
   40050             :   }
   40051           0 :   arg3 = (pointObj *)(argp3);
   40052             :   {
   40053             :     result = (int)lineObj_set(arg1,arg2,arg3); {
   40054           0 :       errorObj *ms_error = msGetErrorObj();
   40055             :       
   40056           0 :       switch(ms_error->code) {
   40057             :       case MS_NOERR:
   40058             :         break;
   40059           0 :       case MS_NOTFOUND:
   40060           0 :         msResetErrorList();
   40061           0 :         break;
   40062             :       case -1:
   40063             :         break;
   40064           0 :       case MS_IOERR:
   40065           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40066           0 :           _raise_ms_exception();
   40067           0 :           msResetErrorList();
   40068           0 :           return NULL;
   40069             :         }
   40070             :       default:
   40071           0 :         _raise_ms_exception();
   40072           0 :         msResetErrorList();
   40073           0 :         return NULL;
   40074             :       }
   40075             :       
   40076             :     }
   40077             :   }
   40078             :   resultobj = SWIG_From_int((int)(result));
   40079           0 :   return resultobj;
   40080           0 : fail:
   40081             :   return NULL;
   40082             : }
   40083             : 
   40084             : 
   40085           1 : SWIGINTERN PyObject *lineObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40086             :   PyObject *obj;
   40087           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   40088           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_lineObj, SWIG_NewClientData(obj));
   40089           1 :   return SWIG_Py_Void();
   40090             : }
   40091             : 
   40092           1 : SWIGINTERN PyObject *_wrap_shapeObj_numlines_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40093             :   PyObject *resultobj = 0;
   40094             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40095           1 :   void *argp1 = 0 ;
   40096             :   int res1 = 0 ;
   40097           1 :   PyObject * obj0 = 0 ;
   40098             :   int result;
   40099             :   
   40100           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_numlines_get",&obj0)) SWIG_fail;
   40101           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40102           1 :   if (!SWIG_IsOK(res1)) {
   40103           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_numlines_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40104             :   }
   40105           1 :   arg1 = (shapeObj *)(argp1);
   40106           1 :   result = (int) ((arg1)->numlines);
   40107             :   resultobj = SWIG_From_int((int)(result));
   40108           1 :   return resultobj;
   40109           0 : fail:
   40110             :   return NULL;
   40111             : }
   40112             : 
   40113             : 
   40114           1 : SWIGINTERN PyObject *_wrap_shapeObj_numvalues_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40115             :   PyObject *resultobj = 0;
   40116             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40117           1 :   void *argp1 = 0 ;
   40118             :   int res1 = 0 ;
   40119           1 :   PyObject * obj0 = 0 ;
   40120             :   int result;
   40121             :   
   40122           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_numvalues_get",&obj0)) SWIG_fail;
   40123           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40124           1 :   if (!SWIG_IsOK(res1)) {
   40125           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_numvalues_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40126             :   }
   40127           1 :   arg1 = (shapeObj *)(argp1);
   40128           1 :   result = (int) ((arg1)->numvalues);
   40129             :   resultobj = SWIG_From_int((int)(result));
   40130           1 :   return resultobj;
   40131           0 : fail:
   40132             :   return NULL;
   40133             : }
   40134             : 
   40135             : 
   40136           0 : SWIGINTERN PyObject *_wrap_shapeObj_bounds_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40137             :   PyObject *resultobj = 0;
   40138             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40139             :   rectObj *arg2 = (rectObj *) 0 ;
   40140           0 :   void *argp1 = 0 ;
   40141             :   int res1 = 0 ;
   40142           0 :   void *argp2 = 0 ;
   40143             :   int res2 = 0 ;
   40144           0 :   PyObject * obj0 = 0 ;
   40145           0 :   PyObject * obj1 = 0 ;
   40146             :   
   40147           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_bounds_set",&obj0,&obj1)) SWIG_fail;
   40148           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40149           0 :   if (!SWIG_IsOK(res1)) {
   40150           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_bounds_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40151             :   }
   40152           0 :   arg1 = (shapeObj *)(argp1);
   40153           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 |  0 );
   40154           0 :   if (!SWIG_IsOK(res2)) {
   40155           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_bounds_set" "', argument " "2"" of type '" "rectObj *""'"); 
   40156             :   }
   40157           0 :   arg2 = (rectObj *)(argp2);
   40158           0 :   if (arg1) (arg1)->bounds = *arg2;
   40159             :   resultobj = SWIG_Py_Void();
   40160           0 :   return resultobj;
   40161           0 : fail:
   40162             :   return NULL;
   40163             : }
   40164             : 
   40165             : 
   40166           1 : SWIGINTERN PyObject *_wrap_shapeObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40167             :   PyObject *resultobj = 0;
   40168             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40169           1 :   void *argp1 = 0 ;
   40170             :   int res1 = 0 ;
   40171           1 :   PyObject * obj0 = 0 ;
   40172             :   rectObj *result = 0 ;
   40173             :   
   40174           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_bounds_get",&obj0)) SWIG_fail;
   40175           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40176           1 :   if (!SWIG_IsOK(res1)) {
   40177           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_bounds_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40178             :   }
   40179           1 :   arg1 = (shapeObj *)(argp1);
   40180           1 :   result = (rectObj *)& ((arg1)->bounds);
   40181           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   40182           1 :   return resultobj;
   40183           0 : fail:
   40184             :   return NULL;
   40185             : }
   40186             : 
   40187             : 
   40188           0 : SWIGINTERN PyObject *_wrap_shapeObj_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40189             :   PyObject *resultobj = 0;
   40190             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40191             :   int arg2 ;
   40192           0 :   void *argp1 = 0 ;
   40193             :   int res1 = 0 ;
   40194             :   int val2 ;
   40195             :   int ecode2 = 0 ;
   40196           0 :   PyObject * obj0 = 0 ;
   40197           0 :   PyObject * obj1 = 0 ;
   40198             :   
   40199           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_type_set",&obj0,&obj1)) SWIG_fail;
   40200           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40201           0 :   if (!SWIG_IsOK(res1)) {
   40202           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_type_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40203             :   }
   40204           0 :   arg1 = (shapeObj *)(argp1);
   40205           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40206           0 :   if (!SWIG_IsOK(ecode2)) {
   40207           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_type_set" "', argument " "2"" of type '" "int""'");
   40208             :   } 
   40209             :   arg2 = (int)(val2);
   40210           0 :   if (arg1) (arg1)->type = arg2;
   40211             :   resultobj = SWIG_Py_Void();
   40212           0 :   return resultobj;
   40213           0 : fail:
   40214             :   return NULL;
   40215             : }
   40216             : 
   40217             : 
   40218           1 : SWIGINTERN PyObject *_wrap_shapeObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40219             :   PyObject *resultobj = 0;
   40220             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40221           1 :   void *argp1 = 0 ;
   40222             :   int res1 = 0 ;
   40223           1 :   PyObject * obj0 = 0 ;
   40224             :   int result;
   40225             :   
   40226           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_type_get",&obj0)) SWIG_fail;
   40227           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40228           1 :   if (!SWIG_IsOK(res1)) {
   40229           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_type_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40230             :   }
   40231           1 :   arg1 = (shapeObj *)(argp1);
   40232           1 :   result = (int) ((arg1)->type);
   40233             :   resultobj = SWIG_From_int((int)(result));
   40234           1 :   return resultobj;
   40235           0 : fail:
   40236             :   return NULL;
   40237             : }
   40238             : 
   40239             : 
   40240           0 : SWIGINTERN PyObject *_wrap_shapeObj_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40241             :   PyObject *resultobj = 0;
   40242             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40243             :   long arg2 ;
   40244           0 :   void *argp1 = 0 ;
   40245             :   int res1 = 0 ;
   40246             :   long val2 ;
   40247             :   int ecode2 = 0 ;
   40248           0 :   PyObject * obj0 = 0 ;
   40249           0 :   PyObject * obj1 = 0 ;
   40250             :   
   40251           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_index_set",&obj0,&obj1)) SWIG_fail;
   40252           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40253           0 :   if (!SWIG_IsOK(res1)) {
   40254           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_index_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40255             :   }
   40256           0 :   arg1 = (shapeObj *)(argp1);
   40257           0 :   ecode2 = SWIG_AsVal_long(obj1, &val2);
   40258           0 :   if (!SWIG_IsOK(ecode2)) {
   40259           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_index_set" "', argument " "2"" of type '" "long""'");
   40260             :   } 
   40261           0 :   arg2 = (long)(val2);
   40262           0 :   if (arg1) (arg1)->index = arg2;
   40263             :   resultobj = SWIG_Py_Void();
   40264           0 :   return resultobj;
   40265           0 : fail:
   40266             :   return NULL;
   40267             : }
   40268             : 
   40269             : 
   40270           0 : SWIGINTERN PyObject *_wrap_shapeObj_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40271             :   PyObject *resultobj = 0;
   40272             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40273           0 :   void *argp1 = 0 ;
   40274             :   int res1 = 0 ;
   40275           0 :   PyObject * obj0 = 0 ;
   40276             :   long result;
   40277             :   
   40278           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_index_get",&obj0)) SWIG_fail;
   40279           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40280           0 :   if (!SWIG_IsOK(res1)) {
   40281           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_index_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40282             :   }
   40283           0 :   arg1 = (shapeObj *)(argp1);
   40284           0 :   result = (long) ((arg1)->index);
   40285           0 :   resultobj = SWIG_From_long((long)(result));
   40286           0 :   return resultobj;
   40287           0 : fail:
   40288             :   return NULL;
   40289             : }
   40290             : 
   40291             : 
   40292           0 : SWIGINTERN PyObject *_wrap_shapeObj_tileindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40293             :   PyObject *resultobj = 0;
   40294             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40295             :   int arg2 ;
   40296           0 :   void *argp1 = 0 ;
   40297             :   int res1 = 0 ;
   40298             :   int val2 ;
   40299             :   int ecode2 = 0 ;
   40300           0 :   PyObject * obj0 = 0 ;
   40301           0 :   PyObject * obj1 = 0 ;
   40302             :   
   40303           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_tileindex_set",&obj0,&obj1)) SWIG_fail;
   40304           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40305           0 :   if (!SWIG_IsOK(res1)) {
   40306           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_tileindex_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40307             :   }
   40308           0 :   arg1 = (shapeObj *)(argp1);
   40309           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40310           0 :   if (!SWIG_IsOK(ecode2)) {
   40311           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_tileindex_set" "', argument " "2"" of type '" "int""'");
   40312             :   } 
   40313             :   arg2 = (int)(val2);
   40314           0 :   if (arg1) (arg1)->tileindex = arg2;
   40315             :   resultobj = SWIG_Py_Void();
   40316           0 :   return resultobj;
   40317           0 : fail:
   40318             :   return NULL;
   40319             : }
   40320             : 
   40321             : 
   40322           0 : SWIGINTERN PyObject *_wrap_shapeObj_tileindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40323             :   PyObject *resultobj = 0;
   40324             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40325           0 :   void *argp1 = 0 ;
   40326             :   int res1 = 0 ;
   40327           0 :   PyObject * obj0 = 0 ;
   40328             :   int result;
   40329             :   
   40330           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_tileindex_get",&obj0)) SWIG_fail;
   40331           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40332           0 :   if (!SWIG_IsOK(res1)) {
   40333           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_tileindex_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40334             :   }
   40335           0 :   arg1 = (shapeObj *)(argp1);
   40336           0 :   result = (int) ((arg1)->tileindex);
   40337             :   resultobj = SWIG_From_int((int)(result));
   40338           0 :   return resultobj;
   40339           0 : fail:
   40340             :   return NULL;
   40341             : }
   40342             : 
   40343             : 
   40344           1 : SWIGINTERN PyObject *_wrap_shapeObj_classindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40345             :   PyObject *resultobj = 0;
   40346             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40347             :   int arg2 ;
   40348           1 :   void *argp1 = 0 ;
   40349             :   int res1 = 0 ;
   40350             :   int val2 ;
   40351             :   int ecode2 = 0 ;
   40352           1 :   PyObject * obj0 = 0 ;
   40353           1 :   PyObject * obj1 = 0 ;
   40354             :   
   40355           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_classindex_set",&obj0,&obj1)) SWIG_fail;
   40356           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40357           1 :   if (!SWIG_IsOK(res1)) {
   40358           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_classindex_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40359             :   }
   40360           1 :   arg1 = (shapeObj *)(argp1);
   40361           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40362           1 :   if (!SWIG_IsOK(ecode2)) {
   40363           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_classindex_set" "', argument " "2"" of type '" "int""'");
   40364             :   } 
   40365             :   arg2 = (int)(val2);
   40366           1 :   if (arg1) (arg1)->classindex = arg2;
   40367             :   resultobj = SWIG_Py_Void();
   40368           1 :   return resultobj;
   40369           0 : fail:
   40370             :   return NULL;
   40371             : }
   40372             : 
   40373             : 
   40374           0 : SWIGINTERN PyObject *_wrap_shapeObj_classindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40375             :   PyObject *resultobj = 0;
   40376             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40377           0 :   void *argp1 = 0 ;
   40378             :   int res1 = 0 ;
   40379           0 :   PyObject * obj0 = 0 ;
   40380             :   int result;
   40381             :   
   40382           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_classindex_get",&obj0)) SWIG_fail;
   40383           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40384           0 :   if (!SWIG_IsOK(res1)) {
   40385           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_classindex_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40386             :   }
   40387           0 :   arg1 = (shapeObj *)(argp1);
   40388           0 :   result = (int) ((arg1)->classindex);
   40389             :   resultobj = SWIG_From_int((int)(result));
   40390           0 :   return resultobj;
   40391           0 : fail:
   40392             :   return NULL;
   40393             : }
   40394             : 
   40395             : 
   40396           1 : SWIGINTERN PyObject *_wrap_shapeObj_text_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40397             :   PyObject *resultobj = 0;
   40398             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40399             :   char *arg2 = (char *) 0 ;
   40400           1 :   void *argp1 = 0 ;
   40401             :   int res1 = 0 ;
   40402             :   int res2 ;
   40403           1 :   char *buf2 = 0 ;
   40404           1 :   int alloc2 = 0 ;
   40405           1 :   PyObject * obj0 = 0 ;
   40406           1 :   PyObject * obj1 = 0 ;
   40407             :   
   40408           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_text_set",&obj0,&obj1)) SWIG_fail;
   40409           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40410           1 :   if (!SWIG_IsOK(res1)) {
   40411           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_text_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40412             :   }
   40413           1 :   arg1 = (shapeObj *)(argp1);
   40414           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   40415           1 :   if (!SWIG_IsOK(res2)) {
   40416           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_text_set" "', argument " "2"" of type '" "char *""'");
   40417             :   }
   40418           1 :   arg2 = (char *)(buf2);
   40419             :   {
   40420           1 :     if (arg1->text) free((char*)arg1->text);
   40421           1 :     if (arg2) {
   40422           1 :       arg1->text = (char *) malloc(strlen(arg2)+1);
   40423             :       strcpy((char*)arg1->text,arg2);
   40424             :     } else {
   40425           0 :       arg1->text = 0;
   40426             :     }
   40427             :   }
   40428             :   resultobj = SWIG_Py_Void();
   40429           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   40430             :   return resultobj;
   40431           0 : fail:
   40432           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   40433             :   return NULL;
   40434             : }
   40435             : 
   40436             : 
   40437           0 : SWIGINTERN PyObject *_wrap_shapeObj_text_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40438             :   PyObject *resultobj = 0;
   40439             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40440           0 :   void *argp1 = 0 ;
   40441             :   int res1 = 0 ;
   40442           0 :   PyObject * obj0 = 0 ;
   40443             :   char *result = 0 ;
   40444             :   
   40445           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_text_get",&obj0)) SWIG_fail;
   40446           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40447           0 :   if (!SWIG_IsOK(res1)) {
   40448           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_text_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40449             :   }
   40450           0 :   arg1 = (shapeObj *)(argp1);
   40451           0 :   result = (char *) ((arg1)->text);
   40452           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   40453           0 :   return resultobj;
   40454           0 : fail:
   40455             :   return NULL;
   40456             : }
   40457             : 
   40458             : 
   40459           0 : SWIGINTERN PyObject *_wrap_shapeObj_scratch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40460             :   PyObject *resultobj = 0;
   40461             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40462             :   int arg2 ;
   40463           0 :   void *argp1 = 0 ;
   40464             :   int res1 = 0 ;
   40465             :   int val2 ;
   40466             :   int ecode2 = 0 ;
   40467           0 :   PyObject * obj0 = 0 ;
   40468           0 :   PyObject * obj1 = 0 ;
   40469             :   
   40470           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_scratch_set",&obj0,&obj1)) SWIG_fail;
   40471           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40472           0 :   if (!SWIG_IsOK(res1)) {
   40473           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_scratch_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40474             :   }
   40475           0 :   arg1 = (shapeObj *)(argp1);
   40476           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40477           0 :   if (!SWIG_IsOK(ecode2)) {
   40478           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_scratch_set" "', argument " "2"" of type '" "int""'");
   40479             :   } 
   40480             :   arg2 = (int)(val2);
   40481           0 :   if (arg1) (arg1)->scratch = arg2;
   40482             :   resultobj = SWIG_Py_Void();
   40483           0 :   return resultobj;
   40484           0 : fail:
   40485             :   return NULL;
   40486             : }
   40487             : 
   40488             : 
   40489           0 : SWIGINTERN PyObject *_wrap_shapeObj_scratch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40490             :   PyObject *resultobj = 0;
   40491             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40492           0 :   void *argp1 = 0 ;
   40493             :   int res1 = 0 ;
   40494           0 :   PyObject * obj0 = 0 ;
   40495             :   int result;
   40496             :   
   40497           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_scratch_get",&obj0)) SWIG_fail;
   40498           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40499           0 :   if (!SWIG_IsOK(res1)) {
   40500           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_scratch_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40501             :   }
   40502           0 :   arg1 = (shapeObj *)(argp1);
   40503           0 :   result = (int) ((arg1)->scratch);
   40504             :   resultobj = SWIG_From_int((int)(result));
   40505           0 :   return resultobj;
   40506           0 : fail:
   40507             :   return NULL;
   40508             : }
   40509             : 
   40510             : 
   40511           0 : SWIGINTERN PyObject *_wrap_shapeObj_resultindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40512             :   PyObject *resultobj = 0;
   40513             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40514             :   int arg2 ;
   40515           0 :   void *argp1 = 0 ;
   40516             :   int res1 = 0 ;
   40517             :   int val2 ;
   40518             :   int ecode2 = 0 ;
   40519           0 :   PyObject * obj0 = 0 ;
   40520           0 :   PyObject * obj1 = 0 ;
   40521             :   
   40522           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_resultindex_set",&obj0,&obj1)) SWIG_fail;
   40523           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40524           0 :   if (!SWIG_IsOK(res1)) {
   40525           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_resultindex_set" "', argument " "1"" of type '" "shapeObj *""'"); 
   40526             :   }
   40527           0 :   arg1 = (shapeObj *)(argp1);
   40528           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40529           0 :   if (!SWIG_IsOK(ecode2)) {
   40530           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_resultindex_set" "', argument " "2"" of type '" "int""'");
   40531             :   } 
   40532             :   arg2 = (int)(val2);
   40533           0 :   if (arg1) (arg1)->resultindex = arg2;
   40534             :   resultobj = SWIG_Py_Void();
   40535           0 :   return resultobj;
   40536           0 : fail:
   40537             :   return NULL;
   40538             : }
   40539             : 
   40540             : 
   40541           0 : SWIGINTERN PyObject *_wrap_shapeObj_resultindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40542             :   PyObject *resultobj = 0;
   40543             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40544           0 :   void *argp1 = 0 ;
   40545             :   int res1 = 0 ;
   40546           0 :   PyObject * obj0 = 0 ;
   40547             :   int result;
   40548             :   
   40549           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_resultindex_get",&obj0)) SWIG_fail;
   40550           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40551           0 :   if (!SWIG_IsOK(res1)) {
   40552           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_resultindex_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40553             :   }
   40554           0 :   arg1 = (shapeObj *)(argp1);
   40555           0 :   result = (int) ((arg1)->resultindex);
   40556             :   resultobj = SWIG_From_int((int)(result));
   40557           0 :   return resultobj;
   40558           0 : fail:
   40559             :   return NULL;
   40560             : }
   40561             : 
   40562             : 
   40563           1 : SWIGINTERN PyObject *_wrap_new_shapeObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40564             :   PyObject *resultobj = 0;
   40565             :   int arg1 = (int) MS_SHAPE_NULL ;
   40566             :   int val1 ;
   40567             :   int ecode1 = 0 ;
   40568           1 :   PyObject * obj0 = 0 ;
   40569             :   shapeObj *result = 0 ;
   40570             :   
   40571           1 :   if (!PyArg_ParseTuple(args,(char *)"|O:new_shapeObj",&obj0)) SWIG_fail;
   40572           1 :   if (obj0) {
   40573             :     ecode1 = SWIG_AsVal_int(obj0, &val1);
   40574           1 :     if (!SWIG_IsOK(ecode1)) {
   40575           0 :       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_shapeObj" "', argument " "1"" of type '" "int""'");
   40576             :     } 
   40577             :     arg1 = (int)(val1);
   40578             :   }
   40579             :   {
   40580           1 :     result = (shapeObj *)new_shapeObj(arg1); {
   40581           1 :       errorObj *ms_error = msGetErrorObj();
   40582             :       
   40583           1 :       switch(ms_error->code) {
   40584             :       case MS_NOERR:
   40585             :         break;
   40586           0 :       case MS_NOTFOUND:
   40587           0 :         msResetErrorList();
   40588           0 :         break;
   40589             :       case -1:
   40590             :         break;
   40591           0 :       case MS_IOERR:
   40592           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40593           0 :           _raise_ms_exception();
   40594           0 :           msResetErrorList();
   40595           0 :           return NULL;
   40596             :         }
   40597             :       default:
   40598           0 :         _raise_ms_exception();
   40599           0 :         msResetErrorList();
   40600           0 :         return NULL;
   40601             :       }
   40602             :       
   40603             :     }
   40604             :   }
   40605           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_NEW |  0 );
   40606           1 :   return resultobj;
   40607           0 : fail:
   40608             :   return NULL;
   40609             : }
   40610             : 
   40611             : 
   40612           1 : SWIGINTERN PyObject *_wrap_delete_shapeObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40613             :   PyObject *resultobj = 0;
   40614             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40615           1 :   void *argp1 = 0 ;
   40616             :   int res1 = 0 ;
   40617           1 :   PyObject * obj0 = 0 ;
   40618             :   
   40619           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_shapeObj",&obj0)) SWIG_fail;
   40620           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, SWIG_POINTER_DISOWN |  0 );
   40621           1 :   if (!SWIG_IsOK(res1)) {
   40622           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_shapeObj" "', argument " "1"" of type '" "shapeObj *""'"); 
   40623             :   }
   40624           1 :   arg1 = (shapeObj *)(argp1);
   40625             :   {
   40626             :     delete_shapeObj(arg1); {
   40627           1 :       errorObj *ms_error = msGetErrorObj();
   40628             :       
   40629           1 :       switch(ms_error->code) {
   40630             :       case MS_NOERR:
   40631             :         break;
   40632           0 :       case MS_NOTFOUND:
   40633           0 :         msResetErrorList();
   40634           0 :         break;
   40635             :       case -1:
   40636             :         break;
   40637           0 :       case MS_IOERR:
   40638           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40639           0 :           _raise_ms_exception();
   40640           0 :           msResetErrorList();
   40641           0 :           return NULL;
   40642             :         }
   40643             :       default:
   40644           0 :         _raise_ms_exception();
   40645           0 :         msResetErrorList();
   40646           0 :         return NULL;
   40647             :       }
   40648             :       
   40649             :     }
   40650             :   }
   40651             :   resultobj = SWIG_Py_Void();
   40652           1 :   return resultobj;
   40653           0 : fail:
   40654             :   return NULL;
   40655             : }
   40656             : 
   40657             : 
   40658           1 : SWIGINTERN PyObject *_wrap_shapeObj_fromWKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40659             :   PyObject *resultobj = 0;
   40660             :   char *arg1 = (char *) 0 ;
   40661             :   int res1 ;
   40662           1 :   char *buf1 = 0 ;
   40663           1 :   int alloc1 = 0 ;
   40664           1 :   PyObject * obj0 = 0 ;
   40665             :   shapeObj *result = 0 ;
   40666             :   
   40667           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_fromWKT",&obj0)) SWIG_fail;
   40668           1 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   40669           1 :   if (!SWIG_IsOK(res1)) {
   40670           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_fromWKT" "', argument " "1"" of type '" "char *""'");
   40671             :   }
   40672           1 :   arg1 = (char *)(buf1);
   40673             :   {
   40674             :     result = (shapeObj *)shapeObj_fromWKT(arg1); {
   40675           1 :       errorObj *ms_error = msGetErrorObj();
   40676             :       
   40677           1 :       switch(ms_error->code) {
   40678             :       case MS_NOERR:
   40679             :         break;
   40680           0 :       case MS_NOTFOUND:
   40681           0 :         msResetErrorList();
   40682           0 :         break;
   40683             :       case -1:
   40684             :         break;
   40685           0 :       case MS_IOERR:
   40686           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40687           0 :           _raise_ms_exception();
   40688           0 :           msResetErrorList();
   40689           0 :           return NULL;
   40690             :         }
   40691             :       default:
   40692           0 :         _raise_ms_exception();
   40693           0 :         msResetErrorList();
   40694           0 :         return NULL;
   40695             :       }
   40696             :       
   40697             :     }
   40698             :   }
   40699           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   40700           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   40701             :   return resultobj;
   40702           0 : fail:
   40703           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   40704             :   return NULL;
   40705             : }
   40706             : 
   40707             : 
   40708           1 : SWIGINTERN PyObject *_wrap_shapeObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40709             :   PyObject *resultobj = 0;
   40710             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40711             :   projectionObj *arg2 = (projectionObj *) 0 ;
   40712             :   projectionObj *arg3 = (projectionObj *) 0 ;
   40713           1 :   void *argp1 = 0 ;
   40714             :   int res1 = 0 ;
   40715           1 :   void *argp2 = 0 ;
   40716             :   int res2 = 0 ;
   40717           1 :   void *argp3 = 0 ;
   40718             :   int res3 = 0 ;
   40719           1 :   PyObject * obj0 = 0 ;
   40720           1 :   PyObject * obj1 = 0 ;
   40721           1 :   PyObject * obj2 = 0 ;
   40722             :   int result;
   40723             :   
   40724           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:shapeObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
   40725           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40726           1 :   if (!SWIG_IsOK(res1)) {
   40727           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_project" "', argument " "1"" of type '" "shapeObj *""'"); 
   40728             :   }
   40729           1 :   arg1 = (shapeObj *)(argp1);
   40730           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 |  0 );
   40731           1 :   if (!SWIG_IsOK(res2)) {
   40732           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_project" "', argument " "2"" of type '" "projectionObj *""'"); 
   40733             :   }
   40734           1 :   arg2 = (projectionObj *)(argp2);
   40735           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 |  0 );
   40736           1 :   if (!SWIG_IsOK(res3)) {
   40737           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapeObj_project" "', argument " "3"" of type '" "projectionObj *""'"); 
   40738             :   }
   40739           1 :   arg3 = (projectionObj *)(argp3);
   40740             :   {
   40741             :     result = (int)shapeObj_project(arg1,arg2,arg3); {
   40742           1 :       errorObj *ms_error = msGetErrorObj();
   40743             :       
   40744           1 :       switch(ms_error->code) {
   40745             :       case MS_NOERR:
   40746             :         break;
   40747           0 :       case MS_NOTFOUND:
   40748           0 :         msResetErrorList();
   40749           0 :         break;
   40750             :       case -1:
   40751             :         break;
   40752           0 :       case MS_IOERR:
   40753           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40754           0 :           _raise_ms_exception();
   40755           0 :           msResetErrorList();
   40756           0 :           return NULL;
   40757             :         }
   40758             :       default:
   40759           0 :         _raise_ms_exception();
   40760           0 :         msResetErrorList();
   40761           0 :         return NULL;
   40762             :       }
   40763             :       
   40764             :     }
   40765             :   }
   40766             :   resultobj = SWIG_From_int((int)(result));
   40767           1 :   return resultobj;
   40768           0 : fail:
   40769             :   return NULL;
   40770             : }
   40771             : 
   40772             : 
   40773           1 : SWIGINTERN PyObject *_wrap_shapeObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40774             :   PyObject *resultobj = 0;
   40775             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40776             :   int arg2 ;
   40777           1 :   void *argp1 = 0 ;
   40778             :   int res1 = 0 ;
   40779             :   int val2 ;
   40780             :   int ecode2 = 0 ;
   40781           1 :   PyObject * obj0 = 0 ;
   40782           1 :   PyObject * obj1 = 0 ;
   40783             :   lineObj *result = 0 ;
   40784             :   
   40785           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_get",&obj0,&obj1)) SWIG_fail;
   40786           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40787           1 :   if (!SWIG_IsOK(res1)) {
   40788           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_get" "', argument " "1"" of type '" "shapeObj *""'"); 
   40789             :   }
   40790           1 :   arg1 = (shapeObj *)(argp1);
   40791           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   40792           1 :   if (!SWIG_IsOK(ecode2)) {
   40793           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_get" "', argument " "2"" of type '" "int""'");
   40794             :   } 
   40795             :   arg2 = (int)(val2);
   40796             :   {
   40797             :     result = (lineObj *)shapeObj_get(arg1,arg2); {
   40798           1 :       errorObj *ms_error = msGetErrorObj();
   40799             :       
   40800           1 :       switch(ms_error->code) {
   40801             :       case MS_NOERR:
   40802             :         break;
   40803           0 :       case MS_NOTFOUND:
   40804           0 :         msResetErrorList();
   40805           0 :         break;
   40806             :       case -1:
   40807             :         break;
   40808           0 :       case MS_IOERR:
   40809           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40810           0 :           _raise_ms_exception();
   40811           0 :           msResetErrorList();
   40812           0 :           return NULL;
   40813             :         }
   40814             :       default:
   40815           0 :         _raise_ms_exception();
   40816           0 :         msResetErrorList();
   40817           0 :         return NULL;
   40818             :       }
   40819             :       
   40820             :     }
   40821             :   }
   40822           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, 0 |  0 );
   40823           1 :   return resultobj;
   40824           0 : fail:
   40825             :   return NULL;
   40826             : }
   40827             : 
   40828             : 
   40829           1 : SWIGINTERN PyObject *_wrap_shapeObj_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40830             :   PyObject *resultobj = 0;
   40831             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40832             :   lineObj *arg2 = (lineObj *) 0 ;
   40833           1 :   void *argp1 = 0 ;
   40834             :   int res1 = 0 ;
   40835           1 :   void *argp2 = 0 ;
   40836             :   int res2 = 0 ;
   40837           1 :   PyObject * obj0 = 0 ;
   40838           1 :   PyObject * obj1 = 0 ;
   40839             :   int result;
   40840             :   
   40841           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_add",&obj0,&obj1)) SWIG_fail;
   40842           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40843           1 :   if (!SWIG_IsOK(res1)) {
   40844           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_add" "', argument " "1"" of type '" "shapeObj *""'"); 
   40845             :   }
   40846           1 :   arg1 = (shapeObj *)(argp1);
   40847           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_lineObj, 0 |  0 );
   40848           1 :   if (!SWIG_IsOK(res2)) {
   40849           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_add" "', argument " "2"" of type '" "lineObj *""'"); 
   40850             :   }
   40851           1 :   arg2 = (lineObj *)(argp2);
   40852             :   {
   40853             :     result = (int)shapeObj_add(arg1,arg2); {
   40854           1 :       errorObj *ms_error = msGetErrorObj();
   40855             :       
   40856           1 :       switch(ms_error->code) {
   40857             :       case MS_NOERR:
   40858             :         break;
   40859           0 :       case MS_NOTFOUND:
   40860           0 :         msResetErrorList();
   40861           0 :         break;
   40862             :       case -1:
   40863             :         break;
   40864           0 :       case MS_IOERR:
   40865           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40866           0 :           _raise_ms_exception();
   40867           0 :           msResetErrorList();
   40868           0 :           return NULL;
   40869             :         }
   40870             :       default:
   40871           0 :         _raise_ms_exception();
   40872           0 :         msResetErrorList();
   40873           0 :         return NULL;
   40874             :       }
   40875             :       
   40876             :     }
   40877             :   }
   40878             :   resultobj = SWIG_From_int((int)(result));
   40879           1 :   return resultobj;
   40880           0 : fail:
   40881             :   return NULL;
   40882             : }
   40883             : 
   40884             : 
   40885           0 : SWIGINTERN PyObject *_wrap_shapeObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40886             :   PyObject *resultobj = 0;
   40887             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40888             :   mapObj *arg2 = (mapObj *) 0 ;
   40889             :   layerObj *arg3 = (layerObj *) 0 ;
   40890             :   imageObj *arg4 = (imageObj *) 0 ;
   40891           0 :   void *argp1 = 0 ;
   40892             :   int res1 = 0 ;
   40893           0 :   void *argp2 = 0 ;
   40894             :   int res2 = 0 ;
   40895           0 :   void *argp3 = 0 ;
   40896             :   int res3 = 0 ;
   40897           0 :   void *argp4 = 0 ;
   40898             :   int res4 = 0 ;
   40899           0 :   PyObject * obj0 = 0 ;
   40900           0 :   PyObject * obj1 = 0 ;
   40901           0 :   PyObject * obj2 = 0 ;
   40902           0 :   PyObject * obj3 = 0 ;
   40903             :   int result;
   40904             :   
   40905           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:shapeObj_draw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   40906           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40907           0 :   if (!SWIG_IsOK(res1)) {
   40908           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_draw" "', argument " "1"" of type '" "shapeObj *""'"); 
   40909             :   }
   40910           0 :   arg1 = (shapeObj *)(argp1);
   40911           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   40912           0 :   if (!SWIG_IsOK(res2)) {
   40913           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_draw" "', argument " "2"" of type '" "mapObj *""'"); 
   40914             :   }
   40915           0 :   arg2 = (mapObj *)(argp2);
   40916           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 |  0 );
   40917           0 :   if (!SWIG_IsOK(res3)) {
   40918           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapeObj_draw" "', argument " "3"" of type '" "layerObj *""'"); 
   40919             :   }
   40920           0 :   arg3 = (layerObj *)(argp3);
   40921           0 :   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_imageObj, 0 |  0 );
   40922           0 :   if (!SWIG_IsOK(res4)) {
   40923           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "shapeObj_draw" "', argument " "4"" of type '" "imageObj *""'"); 
   40924             :   }
   40925           0 :   arg4 = (imageObj *)(argp4);
   40926             :   {
   40927             :     result = (int)shapeObj_draw(arg1,arg2,arg3,arg4); {
   40928           0 :       errorObj *ms_error = msGetErrorObj();
   40929             :       
   40930           0 :       switch(ms_error->code) {
   40931             :       case MS_NOERR:
   40932             :         break;
   40933           0 :       case MS_NOTFOUND:
   40934           0 :         msResetErrorList();
   40935           0 :         break;
   40936             :       case -1:
   40937             :         break;
   40938           0 :       case MS_IOERR:
   40939           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40940           0 :           _raise_ms_exception();
   40941           0 :           msResetErrorList();
   40942           0 :           return NULL;
   40943             :         }
   40944             :       default:
   40945           0 :         _raise_ms_exception();
   40946           0 :         msResetErrorList();
   40947           0 :         return NULL;
   40948             :       }
   40949             :       
   40950             :     }
   40951             :   }
   40952             :   resultobj = SWIG_From_int((int)(result));
   40953           0 :   return resultobj;
   40954           0 : fail:
   40955             :   return NULL;
   40956             : }
   40957             : 
   40958             : 
   40959           1 : SWIGINTERN PyObject *_wrap_shapeObj_setBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   40960             :   PyObject *resultobj = 0;
   40961             :   shapeObj *arg1 = (shapeObj *) 0 ;
   40962           1 :   void *argp1 = 0 ;
   40963             :   int res1 = 0 ;
   40964           1 :   PyObject * obj0 = 0 ;
   40965             :   
   40966           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_setBounds",&obj0)) SWIG_fail;
   40967           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   40968           1 :   if (!SWIG_IsOK(res1)) {
   40969           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_setBounds" "', argument " "1"" of type '" "shapeObj *""'"); 
   40970             :   }
   40971           1 :   arg1 = (shapeObj *)(argp1);
   40972             :   {
   40973             :     shapeObj_setBounds(arg1); {
   40974           1 :       errorObj *ms_error = msGetErrorObj();
   40975             :       
   40976           1 :       switch(ms_error->code) {
   40977             :       case MS_NOERR:
   40978             :         break;
   40979           0 :       case MS_NOTFOUND:
   40980           0 :         msResetErrorList();
   40981           0 :         break;
   40982             :       case -1:
   40983             :         break;
   40984           0 :       case MS_IOERR:
   40985           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   40986           0 :           _raise_ms_exception();
   40987           0 :           msResetErrorList();
   40988           0 :           return NULL;
   40989             :         }
   40990             :       default:
   40991           0 :         _raise_ms_exception();
   40992           0 :         msResetErrorList();
   40993           0 :         return NULL;
   40994             :       }
   40995             :       
   40996             :     }
   40997             :   }
   40998             :   resultobj = SWIG_Py_Void();
   40999           1 :   return resultobj;
   41000           0 : fail:
   41001             :   return NULL;
   41002             : }
   41003             : 
   41004             : 
   41005           1 : SWIGINTERN PyObject *_wrap_shapeObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41006             :   PyObject *resultobj = 0;
   41007             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41008           1 :   void *argp1 = 0 ;
   41009             :   int res1 = 0 ;
   41010           1 :   PyObject * obj0 = 0 ;
   41011             :   shapeObj *result = 0 ;
   41012             :   
   41013           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_clone",&obj0)) SWIG_fail;
   41014           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41015           1 :   if (!SWIG_IsOK(res1)) {
   41016           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_clone" "', argument " "1"" of type '" "shapeObj *""'"); 
   41017             :   }
   41018           1 :   arg1 = (shapeObj *)(argp1);
   41019             :   {
   41020           1 :     result = (shapeObj *)shapeObj_clone(arg1); {
   41021           1 :       errorObj *ms_error = msGetErrorObj();
   41022             :       
   41023           1 :       switch(ms_error->code) {
   41024             :       case MS_NOERR:
   41025             :         break;
   41026           0 :       case MS_NOTFOUND:
   41027           0 :         msResetErrorList();
   41028           0 :         break;
   41029             :       case -1:
   41030             :         break;
   41031           0 :       case MS_IOERR:
   41032           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41033           0 :           _raise_ms_exception();
   41034           0 :           msResetErrorList();
   41035           0 :           return NULL;
   41036             :         }
   41037             :       default:
   41038           0 :         _raise_ms_exception();
   41039           0 :         msResetErrorList();
   41040           0 :         return NULL;
   41041             :       }
   41042             :       
   41043             :     }
   41044             :   }
   41045           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41046           1 :   return resultobj;
   41047           0 : fail:
   41048             :   return NULL;
   41049             : }
   41050             : 
   41051             : 
   41052           0 : SWIGINTERN PyObject *_wrap_shapeObj_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41053             :   PyObject *resultobj = 0;
   41054             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41055             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41056           0 :   void *argp1 = 0 ;
   41057             :   int res1 = 0 ;
   41058           0 :   void *argp2 = 0 ;
   41059             :   int res2 = 0 ;
   41060           0 :   PyObject * obj0 = 0 ;
   41061           0 :   PyObject * obj1 = 0 ;
   41062             :   int result;
   41063             :   
   41064           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_copy",&obj0,&obj1)) SWIG_fail;
   41065           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41066           0 :   if (!SWIG_IsOK(res1)) {
   41067           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_copy" "', argument " "1"" of type '" "shapeObj *""'"); 
   41068             :   }
   41069           0 :   arg1 = (shapeObj *)(argp1);
   41070           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41071           0 :   if (!SWIG_IsOK(res2)) {
   41072           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_copy" "', argument " "2"" of type '" "shapeObj *""'"); 
   41073             :   }
   41074           0 :   arg2 = (shapeObj *)(argp2);
   41075             :   {
   41076             :     result = (int)shapeObj_copy(arg1,arg2); {
   41077           0 :       errorObj *ms_error = msGetErrorObj();
   41078             :       
   41079           0 :       switch(ms_error->code) {
   41080             :       case MS_NOERR:
   41081             :         break;
   41082           0 :       case MS_NOTFOUND:
   41083           0 :         msResetErrorList();
   41084           0 :         break;
   41085             :       case -1:
   41086             :         break;
   41087           0 :       case MS_IOERR:
   41088           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41089           0 :           _raise_ms_exception();
   41090           0 :           msResetErrorList();
   41091           0 :           return NULL;
   41092             :         }
   41093             :       default:
   41094           0 :         _raise_ms_exception();
   41095           0 :         msResetErrorList();
   41096           0 :         return NULL;
   41097             :       }
   41098             :       
   41099             :     }
   41100             :   }
   41101             :   resultobj = SWIG_From_int((int)(result));
   41102           0 :   return resultobj;
   41103           0 : fail:
   41104             :   return NULL;
   41105             : }
   41106             : 
   41107             : 
   41108           1 : SWIGINTERN PyObject *_wrap_shapeObj_toWKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41109             :   PyObject *resultobj = 0;
   41110             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41111           1 :   void *argp1 = 0 ;
   41112             :   int res1 = 0 ;
   41113           1 :   PyObject * obj0 = 0 ;
   41114             :   char *result = 0 ;
   41115             :   
   41116           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_toWKT",&obj0)) SWIG_fail;
   41117           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41118           1 :   if (!SWIG_IsOK(res1)) {
   41119           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_toWKT" "', argument " "1"" of type '" "shapeObj *""'"); 
   41120             :   }
   41121           1 :   arg1 = (shapeObj *)(argp1);
   41122             :   {
   41123             :     result = (char *)shapeObj_toWKT(arg1); {
   41124           1 :       errorObj *ms_error = msGetErrorObj();
   41125             :       
   41126           1 :       switch(ms_error->code) {
   41127             :       case MS_NOERR:
   41128             :         break;
   41129           0 :       case MS_NOTFOUND:
   41130           0 :         msResetErrorList();
   41131           0 :         break;
   41132             :       case -1:
   41133             :         break;
   41134           0 :       case MS_IOERR:
   41135           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41136           0 :           _raise_ms_exception();
   41137           0 :           msResetErrorList();
   41138           0 :           return NULL;
   41139             :         }
   41140             :       default:
   41141           0 :         _raise_ms_exception();
   41142           0 :         msResetErrorList();
   41143           0 :         return NULL;
   41144             :       }
   41145             :       
   41146             :     }
   41147             :   }
   41148           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   41149           1 :   free((char*)result);
   41150           1 :   return resultobj;
   41151           0 : fail:
   41152             :   return NULL;
   41153             : }
   41154             : 
   41155             : 
   41156           0 : SWIGINTERN PyObject *_wrap_shapeObj_buffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41157             :   PyObject *resultobj = 0;
   41158             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41159             :   double arg2 ;
   41160           0 :   void *argp1 = 0 ;
   41161             :   int res1 = 0 ;
   41162             :   double val2 ;
   41163             :   int ecode2 = 0 ;
   41164           0 :   PyObject * obj0 = 0 ;
   41165           0 :   PyObject * obj1 = 0 ;
   41166             :   shapeObj *result = 0 ;
   41167             :   
   41168           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_buffer",&obj0,&obj1)) SWIG_fail;
   41169           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41170           0 :   if (!SWIG_IsOK(res1)) {
   41171           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_buffer" "', argument " "1"" of type '" "shapeObj *""'"); 
   41172             :   }
   41173           0 :   arg1 = (shapeObj *)(argp1);
   41174           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   41175           0 :   if (!SWIG_IsOK(ecode2)) {
   41176           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_buffer" "', argument " "2"" of type '" "double""'");
   41177             :   } 
   41178           0 :   arg2 = (double)(val2);
   41179             :   {
   41180             :     result = (shapeObj *)shapeObj_buffer(arg1,arg2); {
   41181           0 :       errorObj *ms_error = msGetErrorObj();
   41182             :       
   41183           0 :       switch(ms_error->code) {
   41184             :       case MS_NOERR:
   41185             :         break;
   41186           0 :       case MS_NOTFOUND:
   41187           0 :         msResetErrorList();
   41188           0 :         break;
   41189             :       case -1:
   41190             :         break;
   41191           0 :       case MS_IOERR:
   41192           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41193           0 :           _raise_ms_exception();
   41194           0 :           msResetErrorList();
   41195           0 :           return NULL;
   41196             :         }
   41197             :       default:
   41198           0 :         _raise_ms_exception();
   41199           0 :         msResetErrorList();
   41200           0 :         return NULL;
   41201             :       }
   41202             :       
   41203             :     }
   41204             :   }
   41205           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41206           0 :   return resultobj;
   41207           0 : fail:
   41208             :   return NULL;
   41209             : }
   41210             : 
   41211             : 
   41212           0 : SWIGINTERN PyObject *_wrap_shapeObj_simplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41213             :   PyObject *resultobj = 0;
   41214             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41215             :   double arg2 ;
   41216           0 :   void *argp1 = 0 ;
   41217             :   int res1 = 0 ;
   41218             :   double val2 ;
   41219             :   int ecode2 = 0 ;
   41220           0 :   PyObject * obj0 = 0 ;
   41221           0 :   PyObject * obj1 = 0 ;
   41222             :   shapeObj *result = 0 ;
   41223             :   
   41224           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_simplify",&obj0,&obj1)) SWIG_fail;
   41225           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41226           0 :   if (!SWIG_IsOK(res1)) {
   41227           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_simplify" "', argument " "1"" of type '" "shapeObj *""'"); 
   41228             :   }
   41229           0 :   arg1 = (shapeObj *)(argp1);
   41230           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   41231           0 :   if (!SWIG_IsOK(ecode2)) {
   41232           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_simplify" "', argument " "2"" of type '" "double""'");
   41233             :   } 
   41234           0 :   arg2 = (double)(val2);
   41235             :   {
   41236             :     result = (shapeObj *)shapeObj_simplify(arg1,arg2); {
   41237           0 :       errorObj *ms_error = msGetErrorObj();
   41238             :       
   41239           0 :       switch(ms_error->code) {
   41240             :       case MS_NOERR:
   41241             :         break;
   41242           0 :       case MS_NOTFOUND:
   41243           0 :         msResetErrorList();
   41244           0 :         break;
   41245             :       case -1:
   41246             :         break;
   41247           0 :       case MS_IOERR:
   41248           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41249           0 :           _raise_ms_exception();
   41250           0 :           msResetErrorList();
   41251           0 :           return NULL;
   41252             :         }
   41253             :       default:
   41254           0 :         _raise_ms_exception();
   41255           0 :         msResetErrorList();
   41256           0 :         return NULL;
   41257             :       }
   41258             :       
   41259             :     }
   41260             :   }
   41261           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41262           0 :   return resultobj;
   41263           0 : fail:
   41264             :   return NULL;
   41265             : }
   41266             : 
   41267             : 
   41268           0 : SWIGINTERN PyObject *_wrap_shapeObj_topologyPreservingSimplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41269             :   PyObject *resultobj = 0;
   41270             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41271             :   double arg2 ;
   41272           0 :   void *argp1 = 0 ;
   41273             :   int res1 = 0 ;
   41274             :   double val2 ;
   41275             :   int ecode2 = 0 ;
   41276           0 :   PyObject * obj0 = 0 ;
   41277           0 :   PyObject * obj1 = 0 ;
   41278             :   shapeObj *result = 0 ;
   41279             :   
   41280           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_topologyPreservingSimplify",&obj0,&obj1)) SWIG_fail;
   41281           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41282           0 :   if (!SWIG_IsOK(res1)) {
   41283           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_topologyPreservingSimplify" "', argument " "1"" of type '" "shapeObj *""'"); 
   41284             :   }
   41285           0 :   arg1 = (shapeObj *)(argp1);
   41286           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   41287           0 :   if (!SWIG_IsOK(ecode2)) {
   41288           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_topologyPreservingSimplify" "', argument " "2"" of type '" "double""'");
   41289             :   } 
   41290           0 :   arg2 = (double)(val2);
   41291             :   {
   41292             :     result = (shapeObj *)shapeObj_topologyPreservingSimplify(arg1,arg2); {
   41293           0 :       errorObj *ms_error = msGetErrorObj();
   41294             :       
   41295           0 :       switch(ms_error->code) {
   41296             :       case MS_NOERR:
   41297             :         break;
   41298           0 :       case MS_NOTFOUND:
   41299           0 :         msResetErrorList();
   41300           0 :         break;
   41301             :       case -1:
   41302             :         break;
   41303           0 :       case MS_IOERR:
   41304           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41305           0 :           _raise_ms_exception();
   41306           0 :           msResetErrorList();
   41307           0 :           return NULL;
   41308             :         }
   41309             :       default:
   41310           0 :         _raise_ms_exception();
   41311           0 :         msResetErrorList();
   41312           0 :         return NULL;
   41313             :       }
   41314             :       
   41315             :     }
   41316             :   }
   41317           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41318           0 :   return resultobj;
   41319           0 : fail:
   41320             :   return NULL;
   41321             : }
   41322             : 
   41323             : 
   41324           0 : SWIGINTERN PyObject *_wrap_shapeObj_convexHull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41325             :   PyObject *resultobj = 0;
   41326             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41327           0 :   void *argp1 = 0 ;
   41328             :   int res1 = 0 ;
   41329           0 :   PyObject * obj0 = 0 ;
   41330             :   shapeObj *result = 0 ;
   41331             :   
   41332           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_convexHull",&obj0)) SWIG_fail;
   41333           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41334           0 :   if (!SWIG_IsOK(res1)) {
   41335           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_convexHull" "', argument " "1"" of type '" "shapeObj *""'"); 
   41336             :   }
   41337           0 :   arg1 = (shapeObj *)(argp1);
   41338             :   {
   41339             :     result = (shapeObj *)shapeObj_convexHull(arg1); {
   41340           0 :       errorObj *ms_error = msGetErrorObj();
   41341             :       
   41342           0 :       switch(ms_error->code) {
   41343             :       case MS_NOERR:
   41344             :         break;
   41345           0 :       case MS_NOTFOUND:
   41346           0 :         msResetErrorList();
   41347           0 :         break;
   41348             :       case -1:
   41349             :         break;
   41350           0 :       case MS_IOERR:
   41351           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41352           0 :           _raise_ms_exception();
   41353           0 :           msResetErrorList();
   41354           0 :           return NULL;
   41355             :         }
   41356             :       default:
   41357           0 :         _raise_ms_exception();
   41358           0 :         msResetErrorList();
   41359           0 :         return NULL;
   41360             :       }
   41361             :       
   41362             :     }
   41363             :   }
   41364           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41365           0 :   return resultobj;
   41366           0 : fail:
   41367             :   return NULL;
   41368             : }
   41369             : 
   41370             : 
   41371           0 : SWIGINTERN PyObject *_wrap_shapeObj_boundary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41372             :   PyObject *resultobj = 0;
   41373             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41374           0 :   void *argp1 = 0 ;
   41375             :   int res1 = 0 ;
   41376           0 :   PyObject * obj0 = 0 ;
   41377             :   shapeObj *result = 0 ;
   41378             :   
   41379           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_boundary",&obj0)) SWIG_fail;
   41380           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41381           0 :   if (!SWIG_IsOK(res1)) {
   41382           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_boundary" "', argument " "1"" of type '" "shapeObj *""'"); 
   41383             :   }
   41384           0 :   arg1 = (shapeObj *)(argp1);
   41385             :   {
   41386             :     result = (shapeObj *)shapeObj_boundary(arg1); {
   41387           0 :       errorObj *ms_error = msGetErrorObj();
   41388             :       
   41389           0 :       switch(ms_error->code) {
   41390             :       case MS_NOERR:
   41391             :         break;
   41392           0 :       case MS_NOTFOUND:
   41393           0 :         msResetErrorList();
   41394           0 :         break;
   41395             :       case -1:
   41396             :         break;
   41397           0 :       case MS_IOERR:
   41398           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41399           0 :           _raise_ms_exception();
   41400           0 :           msResetErrorList();
   41401           0 :           return NULL;
   41402             :         }
   41403             :       default:
   41404           0 :         _raise_ms_exception();
   41405           0 :         msResetErrorList();
   41406           0 :         return NULL;
   41407             :       }
   41408             :       
   41409             :     }
   41410             :   }
   41411           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41412           0 :   return resultobj;
   41413           0 : fail:
   41414             :   return NULL;
   41415             : }
   41416             : 
   41417             : 
   41418           0 : SWIGINTERN PyObject *_wrap_shapeObj_getCentroid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41419             :   PyObject *resultobj = 0;
   41420             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41421           0 :   void *argp1 = 0 ;
   41422             :   int res1 = 0 ;
   41423           0 :   PyObject * obj0 = 0 ;
   41424             :   pointObj *result = 0 ;
   41425             :   
   41426           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getCentroid",&obj0)) SWIG_fail;
   41427           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41428           0 :   if (!SWIG_IsOK(res1)) {
   41429           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getCentroid" "', argument " "1"" of type '" "shapeObj *""'"); 
   41430             :   }
   41431           0 :   arg1 = (shapeObj *)(argp1);
   41432             :   {
   41433             :     result = (pointObj *)shapeObj_getCentroid(arg1); {
   41434           0 :       errorObj *ms_error = msGetErrorObj();
   41435             :       
   41436           0 :       switch(ms_error->code) {
   41437             :       case MS_NOERR:
   41438             :         break;
   41439           0 :       case MS_NOTFOUND:
   41440           0 :         msResetErrorList();
   41441           0 :         break;
   41442             :       case -1:
   41443             :         break;
   41444           0 :       case MS_IOERR:
   41445           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41446           0 :           _raise_ms_exception();
   41447           0 :           msResetErrorList();
   41448           0 :           return NULL;
   41449             :         }
   41450             :       default:
   41451           0 :         _raise_ms_exception();
   41452           0 :         msResetErrorList();
   41453           0 :         return NULL;
   41454             :       }
   41455             :       
   41456             :     }
   41457             :   }
   41458           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_OWN |  0 );
   41459           0 :   return resultobj;
   41460           0 : fail:
   41461             :   return NULL;
   41462             : }
   41463             : 
   41464             : 
   41465           0 : SWIGINTERN PyObject *_wrap_shapeObj_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41466             :   PyObject *resultobj = 0;
   41467             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41468             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41469           0 :   void *argp1 = 0 ;
   41470             :   int res1 = 0 ;
   41471           0 :   void *argp2 = 0 ;
   41472             :   int res2 = 0 ;
   41473           0 :   PyObject * obj0 = 0 ;
   41474           0 :   PyObject * obj1 = 0 ;
   41475             :   shapeObj *result = 0 ;
   41476             :   
   41477           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_Union",&obj0,&obj1)) SWIG_fail;
   41478           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41479           0 :   if (!SWIG_IsOK(res1)) {
   41480           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_Union" "', argument " "1"" of type '" "shapeObj *""'"); 
   41481             :   }
   41482           0 :   arg1 = (shapeObj *)(argp1);
   41483           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41484           0 :   if (!SWIG_IsOK(res2)) {
   41485           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_Union" "', argument " "2"" of type '" "shapeObj *""'"); 
   41486             :   }
   41487           0 :   arg2 = (shapeObj *)(argp2);
   41488             :   {
   41489             :     result = (shapeObj *)shapeObj_Union(arg1,arg2); {
   41490           0 :       errorObj *ms_error = msGetErrorObj();
   41491             :       
   41492           0 :       switch(ms_error->code) {
   41493             :       case MS_NOERR:
   41494             :         break;
   41495           0 :       case MS_NOTFOUND:
   41496           0 :         msResetErrorList();
   41497           0 :         break;
   41498             :       case -1:
   41499             :         break;
   41500           0 :       case MS_IOERR:
   41501           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41502           0 :           _raise_ms_exception();
   41503           0 :           msResetErrorList();
   41504           0 :           return NULL;
   41505             :         }
   41506             :       default:
   41507           0 :         _raise_ms_exception();
   41508           0 :         msResetErrorList();
   41509           0 :         return NULL;
   41510             :       }
   41511             :       
   41512             :     }
   41513             :   }
   41514           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41515           0 :   return resultobj;
   41516           0 : fail:
   41517             :   return NULL;
   41518             : }
   41519             : 
   41520             : 
   41521           0 : SWIGINTERN PyObject *_wrap_shapeObj_intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41522             :   PyObject *resultobj = 0;
   41523             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41524             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41525           0 :   void *argp1 = 0 ;
   41526             :   int res1 = 0 ;
   41527           0 :   void *argp2 = 0 ;
   41528             :   int res2 = 0 ;
   41529           0 :   PyObject * obj0 = 0 ;
   41530           0 :   PyObject * obj1 = 0 ;
   41531             :   shapeObj *result = 0 ;
   41532             :   
   41533           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_intersection",&obj0,&obj1)) SWIG_fail;
   41534           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41535           0 :   if (!SWIG_IsOK(res1)) {
   41536           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_intersection" "', argument " "1"" of type '" "shapeObj *""'"); 
   41537             :   }
   41538           0 :   arg1 = (shapeObj *)(argp1);
   41539           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41540           0 :   if (!SWIG_IsOK(res2)) {
   41541           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_intersection" "', argument " "2"" of type '" "shapeObj *""'"); 
   41542             :   }
   41543           0 :   arg2 = (shapeObj *)(argp2);
   41544             :   {
   41545             :     result = (shapeObj *)shapeObj_intersection(arg1,arg2); {
   41546           0 :       errorObj *ms_error = msGetErrorObj();
   41547             :       
   41548           0 :       switch(ms_error->code) {
   41549             :       case MS_NOERR:
   41550             :         break;
   41551           0 :       case MS_NOTFOUND:
   41552           0 :         msResetErrorList();
   41553           0 :         break;
   41554             :       case -1:
   41555             :         break;
   41556           0 :       case MS_IOERR:
   41557           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41558           0 :           _raise_ms_exception();
   41559           0 :           msResetErrorList();
   41560           0 :           return NULL;
   41561             :         }
   41562             :       default:
   41563           0 :         _raise_ms_exception();
   41564           0 :         msResetErrorList();
   41565           0 :         return NULL;
   41566             :       }
   41567             :       
   41568             :     }
   41569             :   }
   41570           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41571           0 :   return resultobj;
   41572           0 : fail:
   41573             :   return NULL;
   41574             : }
   41575             : 
   41576             : 
   41577           0 : SWIGINTERN PyObject *_wrap_shapeObj_difference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41578             :   PyObject *resultobj = 0;
   41579             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41580             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41581           0 :   void *argp1 = 0 ;
   41582             :   int res1 = 0 ;
   41583           0 :   void *argp2 = 0 ;
   41584             :   int res2 = 0 ;
   41585           0 :   PyObject * obj0 = 0 ;
   41586           0 :   PyObject * obj1 = 0 ;
   41587             :   shapeObj *result = 0 ;
   41588             :   
   41589           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_difference",&obj0,&obj1)) SWIG_fail;
   41590           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41591           0 :   if (!SWIG_IsOK(res1)) {
   41592           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_difference" "', argument " "1"" of type '" "shapeObj *""'"); 
   41593             :   }
   41594           0 :   arg1 = (shapeObj *)(argp1);
   41595           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41596           0 :   if (!SWIG_IsOK(res2)) {
   41597           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_difference" "', argument " "2"" of type '" "shapeObj *""'"); 
   41598             :   }
   41599           0 :   arg2 = (shapeObj *)(argp2);
   41600             :   {
   41601             :     result = (shapeObj *)shapeObj_difference(arg1,arg2); {
   41602           0 :       errorObj *ms_error = msGetErrorObj();
   41603             :       
   41604           0 :       switch(ms_error->code) {
   41605             :       case MS_NOERR:
   41606             :         break;
   41607           0 :       case MS_NOTFOUND:
   41608           0 :         msResetErrorList();
   41609           0 :         break;
   41610             :       case -1:
   41611             :         break;
   41612           0 :       case MS_IOERR:
   41613           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41614           0 :           _raise_ms_exception();
   41615           0 :           msResetErrorList();
   41616           0 :           return NULL;
   41617             :         }
   41618             :       default:
   41619           0 :         _raise_ms_exception();
   41620           0 :         msResetErrorList();
   41621           0 :         return NULL;
   41622             :       }
   41623             :       
   41624             :     }
   41625             :   }
   41626           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41627           0 :   return resultobj;
   41628           0 : fail:
   41629             :   return NULL;
   41630             : }
   41631             : 
   41632             : 
   41633           0 : SWIGINTERN PyObject *_wrap_shapeObj_symDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41634             :   PyObject *resultobj = 0;
   41635             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41636             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41637           0 :   void *argp1 = 0 ;
   41638             :   int res1 = 0 ;
   41639           0 :   void *argp2 = 0 ;
   41640             :   int res2 = 0 ;
   41641           0 :   PyObject * obj0 = 0 ;
   41642           0 :   PyObject * obj1 = 0 ;
   41643             :   shapeObj *result = 0 ;
   41644             :   
   41645           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_symDifference",&obj0,&obj1)) SWIG_fail;
   41646           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41647           0 :   if (!SWIG_IsOK(res1)) {
   41648           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_symDifference" "', argument " "1"" of type '" "shapeObj *""'"); 
   41649             :   }
   41650           0 :   arg1 = (shapeObj *)(argp1);
   41651           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41652           0 :   if (!SWIG_IsOK(res2)) {
   41653           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_symDifference" "', argument " "2"" of type '" "shapeObj *""'"); 
   41654             :   }
   41655           0 :   arg2 = (shapeObj *)(argp2);
   41656             :   {
   41657             :     result = (shapeObj *)shapeObj_symDifference(arg1,arg2); {
   41658           0 :       errorObj *ms_error = msGetErrorObj();
   41659             :       
   41660           0 :       switch(ms_error->code) {
   41661             :       case MS_NOERR:
   41662             :         break;
   41663           0 :       case MS_NOTFOUND:
   41664           0 :         msResetErrorList();
   41665           0 :         break;
   41666             :       case -1:
   41667             :         break;
   41668           0 :       case MS_IOERR:
   41669           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41670           0 :           _raise_ms_exception();
   41671           0 :           msResetErrorList();
   41672           0 :           return NULL;
   41673             :         }
   41674             :       default:
   41675           0 :         _raise_ms_exception();
   41676           0 :         msResetErrorList();
   41677           0 :         return NULL;
   41678             :       }
   41679             :       
   41680             :     }
   41681             :   }
   41682           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   41683           0 :   return resultobj;
   41684           0 : fail:
   41685             :   return NULL;
   41686             : }
   41687             : 
   41688             : 
   41689           0 : SWIGINTERN PyObject *_wrap_shapeObj_contains__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41690             :   PyObject *resultobj = 0;
   41691             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41692             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41693           0 :   void *argp1 = 0 ;
   41694             :   int res1 = 0 ;
   41695           0 :   void *argp2 = 0 ;
   41696             :   int res2 = 0 ;
   41697           0 :   PyObject * obj0 = 0 ;
   41698           0 :   PyObject * obj1 = 0 ;
   41699             :   int result;
   41700             :   
   41701           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_contains",&obj0,&obj1)) SWIG_fail;
   41702           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41703           0 :   if (!SWIG_IsOK(res1)) {
   41704           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_contains" "', argument " "1"" of type '" "shapeObj *""'"); 
   41705             :   }
   41706           0 :   arg1 = (shapeObj *)(argp1);
   41707           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41708           0 :   if (!SWIG_IsOK(res2)) {
   41709           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_contains" "', argument " "2"" of type '" "shapeObj *""'"); 
   41710             :   }
   41711           0 :   arg2 = (shapeObj *)(argp2);
   41712             :   {
   41713             :     result = (int)shapeObj_contains__SWIG_0(arg1,arg2); {
   41714           0 :       errorObj *ms_error = msGetErrorObj();
   41715             :       
   41716           0 :       switch(ms_error->code) {
   41717             :       case MS_NOERR:
   41718             :         break;
   41719           0 :       case MS_NOTFOUND:
   41720           0 :         msResetErrorList();
   41721             :         break;
   41722             :       case -1:
   41723             :         break;
   41724           0 :       case MS_IOERR:
   41725           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41726           0 :           _raise_ms_exception();
   41727           0 :           msResetErrorList();
   41728             :           return NULL;
   41729             :         }
   41730             :       default:
   41731           0 :         _raise_ms_exception();
   41732           0 :         msResetErrorList();
   41733             :         return NULL;
   41734             :       }
   41735             :       
   41736             :     }
   41737             :   }
   41738             :   resultobj = SWIG_From_int((int)(result));
   41739             :   return resultobj;
   41740             : fail:
   41741             :   return NULL;
   41742             : }
   41743             : 
   41744             : 
   41745           0 : SWIGINTERN PyObject *_wrap_shapeObj_overlaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41746             :   PyObject *resultobj = 0;
   41747             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41748             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41749           0 :   void *argp1 = 0 ;
   41750             :   int res1 = 0 ;
   41751           0 :   void *argp2 = 0 ;
   41752             :   int res2 = 0 ;
   41753           0 :   PyObject * obj0 = 0 ;
   41754           0 :   PyObject * obj1 = 0 ;
   41755             :   int result;
   41756             :   
   41757           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_overlaps",&obj0,&obj1)) SWIG_fail;
   41758           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41759           0 :   if (!SWIG_IsOK(res1)) {
   41760           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_overlaps" "', argument " "1"" of type '" "shapeObj *""'"); 
   41761             :   }
   41762           0 :   arg1 = (shapeObj *)(argp1);
   41763           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41764           0 :   if (!SWIG_IsOK(res2)) {
   41765           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_overlaps" "', argument " "2"" of type '" "shapeObj *""'"); 
   41766             :   }
   41767           0 :   arg2 = (shapeObj *)(argp2);
   41768             :   {
   41769             :     result = (int)shapeObj_overlaps(arg1,arg2); {
   41770           0 :       errorObj *ms_error = msGetErrorObj();
   41771             :       
   41772           0 :       switch(ms_error->code) {
   41773             :       case MS_NOERR:
   41774             :         break;
   41775           0 :       case MS_NOTFOUND:
   41776           0 :         msResetErrorList();
   41777           0 :         break;
   41778             :       case -1:
   41779             :         break;
   41780           0 :       case MS_IOERR:
   41781           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41782           0 :           _raise_ms_exception();
   41783           0 :           msResetErrorList();
   41784           0 :           return NULL;
   41785             :         }
   41786             :       default:
   41787           0 :         _raise_ms_exception();
   41788           0 :         msResetErrorList();
   41789           0 :         return NULL;
   41790             :       }
   41791             :       
   41792             :     }
   41793             :   }
   41794             :   resultobj = SWIG_From_int((int)(result));
   41795           0 :   return resultobj;
   41796           0 : fail:
   41797             :   return NULL;
   41798             : }
   41799             : 
   41800             : 
   41801           0 : SWIGINTERN PyObject *_wrap_shapeObj_within(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41802             :   PyObject *resultobj = 0;
   41803             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41804             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41805           0 :   void *argp1 = 0 ;
   41806             :   int res1 = 0 ;
   41807           0 :   void *argp2 = 0 ;
   41808             :   int res2 = 0 ;
   41809           0 :   PyObject * obj0 = 0 ;
   41810           0 :   PyObject * obj1 = 0 ;
   41811             :   int result;
   41812             :   
   41813           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_within",&obj0,&obj1)) SWIG_fail;
   41814           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41815           0 :   if (!SWIG_IsOK(res1)) {
   41816           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_within" "', argument " "1"" of type '" "shapeObj *""'"); 
   41817             :   }
   41818           0 :   arg1 = (shapeObj *)(argp1);
   41819           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41820           0 :   if (!SWIG_IsOK(res2)) {
   41821           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_within" "', argument " "2"" of type '" "shapeObj *""'"); 
   41822             :   }
   41823           0 :   arg2 = (shapeObj *)(argp2);
   41824             :   {
   41825             :     result = (int)shapeObj_within(arg1,arg2); {
   41826           0 :       errorObj *ms_error = msGetErrorObj();
   41827             :       
   41828           0 :       switch(ms_error->code) {
   41829             :       case MS_NOERR:
   41830             :         break;
   41831           0 :       case MS_NOTFOUND:
   41832           0 :         msResetErrorList();
   41833           0 :         break;
   41834             :       case -1:
   41835             :         break;
   41836           0 :       case MS_IOERR:
   41837           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41838           0 :           _raise_ms_exception();
   41839           0 :           msResetErrorList();
   41840           0 :           return NULL;
   41841             :         }
   41842             :       default:
   41843           0 :         _raise_ms_exception();
   41844           0 :         msResetErrorList();
   41845           0 :         return NULL;
   41846             :       }
   41847             :       
   41848             :     }
   41849             :   }
   41850             :   resultobj = SWIG_From_int((int)(result));
   41851           0 :   return resultobj;
   41852           0 : fail:
   41853             :   return NULL;
   41854             : }
   41855             : 
   41856             : 
   41857           0 : SWIGINTERN PyObject *_wrap_shapeObj_crosses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41858             :   PyObject *resultobj = 0;
   41859             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41860             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41861           0 :   void *argp1 = 0 ;
   41862             :   int res1 = 0 ;
   41863           0 :   void *argp2 = 0 ;
   41864             :   int res2 = 0 ;
   41865           0 :   PyObject * obj0 = 0 ;
   41866           0 :   PyObject * obj1 = 0 ;
   41867             :   int result;
   41868             :   
   41869           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_crosses",&obj0,&obj1)) SWIG_fail;
   41870           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41871           0 :   if (!SWIG_IsOK(res1)) {
   41872           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_crosses" "', argument " "1"" of type '" "shapeObj *""'"); 
   41873             :   }
   41874           0 :   arg1 = (shapeObj *)(argp1);
   41875           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41876           0 :   if (!SWIG_IsOK(res2)) {
   41877           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_crosses" "', argument " "2"" of type '" "shapeObj *""'"); 
   41878             :   }
   41879           0 :   arg2 = (shapeObj *)(argp2);
   41880             :   {
   41881             :     result = (int)shapeObj_crosses(arg1,arg2); {
   41882           0 :       errorObj *ms_error = msGetErrorObj();
   41883             :       
   41884           0 :       switch(ms_error->code) {
   41885             :       case MS_NOERR:
   41886             :         break;
   41887           0 :       case MS_NOTFOUND:
   41888           0 :         msResetErrorList();
   41889           0 :         break;
   41890             :       case -1:
   41891             :         break;
   41892           0 :       case MS_IOERR:
   41893           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41894           0 :           _raise_ms_exception();
   41895           0 :           msResetErrorList();
   41896           0 :           return NULL;
   41897             :         }
   41898             :       default:
   41899           0 :         _raise_ms_exception();
   41900           0 :         msResetErrorList();
   41901           0 :         return NULL;
   41902             :       }
   41903             :       
   41904             :     }
   41905             :   }
   41906             :   resultobj = SWIG_From_int((int)(result));
   41907           0 :   return resultobj;
   41908           0 : fail:
   41909             :   return NULL;
   41910             : }
   41911             : 
   41912             : 
   41913           0 : SWIGINTERN PyObject *_wrap_shapeObj_intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41914             :   PyObject *resultobj = 0;
   41915             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41916             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41917           0 :   void *argp1 = 0 ;
   41918             :   int res1 = 0 ;
   41919           0 :   void *argp2 = 0 ;
   41920             :   int res2 = 0 ;
   41921           0 :   PyObject * obj0 = 0 ;
   41922           0 :   PyObject * obj1 = 0 ;
   41923             :   int result;
   41924             :   
   41925           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_intersects",&obj0,&obj1)) SWIG_fail;
   41926           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41927           0 :   if (!SWIG_IsOK(res1)) {
   41928           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_intersects" "', argument " "1"" of type '" "shapeObj *""'"); 
   41929             :   }
   41930           0 :   arg1 = (shapeObj *)(argp1);
   41931           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41932           0 :   if (!SWIG_IsOK(res2)) {
   41933           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_intersects" "', argument " "2"" of type '" "shapeObj *""'"); 
   41934             :   }
   41935           0 :   arg2 = (shapeObj *)(argp2);
   41936             :   {
   41937             :     result = (int)shapeObj_intersects(arg1,arg2); {
   41938           0 :       errorObj *ms_error = msGetErrorObj();
   41939             :       
   41940           0 :       switch(ms_error->code) {
   41941             :       case MS_NOERR:
   41942             :         break;
   41943           0 :       case MS_NOTFOUND:
   41944           0 :         msResetErrorList();
   41945           0 :         break;
   41946             :       case -1:
   41947             :         break;
   41948           0 :       case MS_IOERR:
   41949           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   41950           0 :           _raise_ms_exception();
   41951           0 :           msResetErrorList();
   41952           0 :           return NULL;
   41953             :         }
   41954             :       default:
   41955           0 :         _raise_ms_exception();
   41956           0 :         msResetErrorList();
   41957           0 :         return NULL;
   41958             :       }
   41959             :       
   41960             :     }
   41961             :   }
   41962             :   resultobj = SWIG_From_int((int)(result));
   41963           0 :   return resultobj;
   41964           0 : fail:
   41965             :   return NULL;
   41966             : }
   41967             : 
   41968             : 
   41969           0 : SWIGINTERN PyObject *_wrap_shapeObj_touches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   41970             :   PyObject *resultobj = 0;
   41971             :   shapeObj *arg1 = (shapeObj *) 0 ;
   41972             :   shapeObj *arg2 = (shapeObj *) 0 ;
   41973           0 :   void *argp1 = 0 ;
   41974             :   int res1 = 0 ;
   41975           0 :   void *argp2 = 0 ;
   41976             :   int res2 = 0 ;
   41977           0 :   PyObject * obj0 = 0 ;
   41978           0 :   PyObject * obj1 = 0 ;
   41979             :   int result;
   41980             :   
   41981           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_touches",&obj0,&obj1)) SWIG_fail;
   41982           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   41983           0 :   if (!SWIG_IsOK(res1)) {
   41984           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_touches" "', argument " "1"" of type '" "shapeObj *""'"); 
   41985             :   }
   41986           0 :   arg1 = (shapeObj *)(argp1);
   41987           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   41988           0 :   if (!SWIG_IsOK(res2)) {
   41989           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_touches" "', argument " "2"" of type '" "shapeObj *""'"); 
   41990             :   }
   41991           0 :   arg2 = (shapeObj *)(argp2);
   41992             :   {
   41993             :     result = (int)shapeObj_touches(arg1,arg2); {
   41994           0 :       errorObj *ms_error = msGetErrorObj();
   41995             :       
   41996           0 :       switch(ms_error->code) {
   41997             :       case MS_NOERR:
   41998             :         break;
   41999           0 :       case MS_NOTFOUND:
   42000           0 :         msResetErrorList();
   42001           0 :         break;
   42002             :       case -1:
   42003             :         break;
   42004           0 :       case MS_IOERR:
   42005           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42006           0 :           _raise_ms_exception();
   42007           0 :           msResetErrorList();
   42008           0 :           return NULL;
   42009             :         }
   42010             :       default:
   42011           0 :         _raise_ms_exception();
   42012           0 :         msResetErrorList();
   42013           0 :         return NULL;
   42014             :       }
   42015             :       
   42016             :     }
   42017             :   }
   42018             :   resultobj = SWIG_From_int((int)(result));
   42019           0 :   return resultobj;
   42020           0 : fail:
   42021             :   return NULL;
   42022             : }
   42023             : 
   42024             : 
   42025           0 : SWIGINTERN PyObject *_wrap_shapeObj_equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42026             :   PyObject *resultobj = 0;
   42027             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42028             :   shapeObj *arg2 = (shapeObj *) 0 ;
   42029           0 :   void *argp1 = 0 ;
   42030             :   int res1 = 0 ;
   42031           0 :   void *argp2 = 0 ;
   42032             :   int res2 = 0 ;
   42033           0 :   PyObject * obj0 = 0 ;
   42034           0 :   PyObject * obj1 = 0 ;
   42035             :   int result;
   42036             :   
   42037           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_equals",&obj0,&obj1)) SWIG_fail;
   42038           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42039           0 :   if (!SWIG_IsOK(res1)) {
   42040           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_equals" "', argument " "1"" of type '" "shapeObj *""'"); 
   42041             :   }
   42042           0 :   arg1 = (shapeObj *)(argp1);
   42043           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   42044           0 :   if (!SWIG_IsOK(res2)) {
   42045           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_equals" "', argument " "2"" of type '" "shapeObj *""'"); 
   42046             :   }
   42047           0 :   arg2 = (shapeObj *)(argp2);
   42048             :   {
   42049             :     result = (int)shapeObj_equals(arg1,arg2); {
   42050           0 :       errorObj *ms_error = msGetErrorObj();
   42051             :       
   42052           0 :       switch(ms_error->code) {
   42053             :       case MS_NOERR:
   42054             :         break;
   42055           0 :       case MS_NOTFOUND:
   42056           0 :         msResetErrorList();
   42057           0 :         break;
   42058             :       case -1:
   42059             :         break;
   42060           0 :       case MS_IOERR:
   42061           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42062           0 :           _raise_ms_exception();
   42063           0 :           msResetErrorList();
   42064           0 :           return NULL;
   42065             :         }
   42066             :       default:
   42067           0 :         _raise_ms_exception();
   42068           0 :         msResetErrorList();
   42069           0 :         return NULL;
   42070             :       }
   42071             :       
   42072             :     }
   42073             :   }
   42074             :   resultobj = SWIG_From_int((int)(result));
   42075           0 :   return resultobj;
   42076           0 : fail:
   42077             :   return NULL;
   42078             : }
   42079             : 
   42080             : 
   42081           0 : SWIGINTERN PyObject *_wrap_shapeObj_disjoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42082             :   PyObject *resultobj = 0;
   42083             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42084             :   shapeObj *arg2 = (shapeObj *) 0 ;
   42085           0 :   void *argp1 = 0 ;
   42086             :   int res1 = 0 ;
   42087           0 :   void *argp2 = 0 ;
   42088             :   int res2 = 0 ;
   42089           0 :   PyObject * obj0 = 0 ;
   42090           0 :   PyObject * obj1 = 0 ;
   42091             :   int result;
   42092             :   
   42093           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_disjoint",&obj0,&obj1)) SWIG_fail;
   42094           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42095           0 :   if (!SWIG_IsOK(res1)) {
   42096           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_disjoint" "', argument " "1"" of type '" "shapeObj *""'"); 
   42097             :   }
   42098           0 :   arg1 = (shapeObj *)(argp1);
   42099           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   42100           0 :   if (!SWIG_IsOK(res2)) {
   42101           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_disjoint" "', argument " "2"" of type '" "shapeObj *""'"); 
   42102             :   }
   42103           0 :   arg2 = (shapeObj *)(argp2);
   42104             :   {
   42105             :     result = (int)shapeObj_disjoint(arg1,arg2); {
   42106           0 :       errorObj *ms_error = msGetErrorObj();
   42107             :       
   42108           0 :       switch(ms_error->code) {
   42109             :       case MS_NOERR:
   42110             :         break;
   42111           0 :       case MS_NOTFOUND:
   42112           0 :         msResetErrorList();
   42113           0 :         break;
   42114             :       case -1:
   42115             :         break;
   42116           0 :       case MS_IOERR:
   42117           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42118           0 :           _raise_ms_exception();
   42119           0 :           msResetErrorList();
   42120           0 :           return NULL;
   42121             :         }
   42122             :       default:
   42123           0 :         _raise_ms_exception();
   42124           0 :         msResetErrorList();
   42125           0 :         return NULL;
   42126             :       }
   42127             :       
   42128             :     }
   42129             :   }
   42130             :   resultobj = SWIG_From_int((int)(result));
   42131           0 :   return resultobj;
   42132           0 : fail:
   42133             :   return NULL;
   42134             : }
   42135             : 
   42136             : 
   42137           0 : SWIGINTERN PyObject *_wrap_shapeObj_getArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42138             :   PyObject *resultobj = 0;
   42139             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42140           0 :   void *argp1 = 0 ;
   42141             :   int res1 = 0 ;
   42142           0 :   PyObject * obj0 = 0 ;
   42143             :   double result;
   42144             :   
   42145           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getArea",&obj0)) SWIG_fail;
   42146           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42147           0 :   if (!SWIG_IsOK(res1)) {
   42148           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getArea" "', argument " "1"" of type '" "shapeObj *""'"); 
   42149             :   }
   42150           0 :   arg1 = (shapeObj *)(argp1);
   42151             :   {
   42152             :     result = (double)shapeObj_getArea(arg1); {
   42153           0 :       errorObj *ms_error = msGetErrorObj();
   42154             :       
   42155           0 :       switch(ms_error->code) {
   42156             :       case MS_NOERR:
   42157             :         break;
   42158           0 :       case MS_NOTFOUND:
   42159           0 :         msResetErrorList();
   42160           0 :         break;
   42161             :       case -1:
   42162             :         break;
   42163           0 :       case MS_IOERR:
   42164           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42165           0 :           _raise_ms_exception();
   42166           0 :           msResetErrorList();
   42167           0 :           return NULL;
   42168             :         }
   42169             :       default:
   42170           0 :         _raise_ms_exception();
   42171           0 :         msResetErrorList();
   42172           0 :         return NULL;
   42173             :       }
   42174             :       
   42175             :     }
   42176             :   }
   42177           0 :   resultobj = SWIG_From_double((double)(result));
   42178           0 :   return resultobj;
   42179           0 : fail:
   42180             :   return NULL;
   42181             : }
   42182             : 
   42183             : 
   42184           0 : SWIGINTERN PyObject *_wrap_shapeObj_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42185             :   PyObject *resultobj = 0;
   42186             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42187           0 :   void *argp1 = 0 ;
   42188             :   int res1 = 0 ;
   42189           0 :   PyObject * obj0 = 0 ;
   42190             :   double result;
   42191             :   
   42192           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getLength",&obj0)) SWIG_fail;
   42193           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42194           0 :   if (!SWIG_IsOK(res1)) {
   42195           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getLength" "', argument " "1"" of type '" "shapeObj *""'"); 
   42196             :   }
   42197           0 :   arg1 = (shapeObj *)(argp1);
   42198             :   {
   42199             :     result = (double)shapeObj_getLength(arg1); {
   42200           0 :       errorObj *ms_error = msGetErrorObj();
   42201             :       
   42202           0 :       switch(ms_error->code) {
   42203             :       case MS_NOERR:
   42204             :         break;
   42205           0 :       case MS_NOTFOUND:
   42206           0 :         msResetErrorList();
   42207           0 :         break;
   42208             :       case -1:
   42209             :         break;
   42210           0 :       case MS_IOERR:
   42211           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42212           0 :           _raise_ms_exception();
   42213           0 :           msResetErrorList();
   42214           0 :           return NULL;
   42215             :         }
   42216             :       default:
   42217           0 :         _raise_ms_exception();
   42218           0 :         msResetErrorList();
   42219           0 :         return NULL;
   42220             :       }
   42221             :       
   42222             :     }
   42223             :   }
   42224           0 :   resultobj = SWIG_From_double((double)(result));
   42225           0 :   return resultobj;
   42226           0 : fail:
   42227             :   return NULL;
   42228             : }
   42229             : 
   42230             : 
   42231           1 : SWIGINTERN PyObject *_wrap_shapeObj_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42232             :   PyObject *resultobj = 0;
   42233             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42234             :   int arg2 ;
   42235           1 :   void *argp1 = 0 ;
   42236             :   int res1 = 0 ;
   42237             :   int val2 ;
   42238             :   int ecode2 = 0 ;
   42239           1 :   PyObject * obj0 = 0 ;
   42240           1 :   PyObject * obj1 = 0 ;
   42241             :   char *result = 0 ;
   42242             :   
   42243           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_getValue",&obj0,&obj1)) SWIG_fail;
   42244           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42245           1 :   if (!SWIG_IsOK(res1)) {
   42246           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getValue" "', argument " "1"" of type '" "shapeObj *""'"); 
   42247             :   }
   42248           1 :   arg1 = (shapeObj *)(argp1);
   42249           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   42250           1 :   if (!SWIG_IsOK(ecode2)) {
   42251           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_getValue" "', argument " "2"" of type '" "int""'");
   42252             :   } 
   42253             :   arg2 = (int)(val2);
   42254             :   {
   42255             :     result = (char *)shapeObj_getValue(arg1,arg2); {
   42256           1 :       errorObj *ms_error = msGetErrorObj();
   42257             :       
   42258           1 :       switch(ms_error->code) {
   42259             :       case MS_NOERR:
   42260             :         break;
   42261           0 :       case MS_NOTFOUND:
   42262           0 :         msResetErrorList();
   42263           0 :         break;
   42264             :       case -1:
   42265             :         break;
   42266           0 :       case MS_IOERR:
   42267           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42268           0 :           _raise_ms_exception();
   42269           0 :           msResetErrorList();
   42270           0 :           return NULL;
   42271             :         }
   42272             :       default:
   42273           0 :         _raise_ms_exception();
   42274           0 :         msResetErrorList();
   42275           0 :         return NULL;
   42276             :       }
   42277             :       
   42278             :     }
   42279             :   }
   42280           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   42281           1 :   return resultobj;
   42282           0 : fail:
   42283             :   return NULL;
   42284             : }
   42285             : 
   42286             : 
   42287           0 : SWIGINTERN PyObject *_wrap_shapeObj_contains__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42288             :   PyObject *resultobj = 0;
   42289             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42290             :   pointObj *arg2 = (pointObj *) 0 ;
   42291           0 :   void *argp1 = 0 ;
   42292             :   int res1 = 0 ;
   42293           0 :   void *argp2 = 0 ;
   42294             :   int res2 = 0 ;
   42295           0 :   PyObject * obj0 = 0 ;
   42296           0 :   PyObject * obj1 = 0 ;
   42297             :   int result;
   42298             :   
   42299           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_contains",&obj0,&obj1)) SWIG_fail;
   42300           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42301           0 :   if (!SWIG_IsOK(res1)) {
   42302           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_contains" "', argument " "1"" of type '" "shapeObj *""'"); 
   42303             :   }
   42304           0 :   arg1 = (shapeObj *)(argp1);
   42305           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   42306           0 :   if (!SWIG_IsOK(res2)) {
   42307           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_contains" "', argument " "2"" of type '" "pointObj *""'"); 
   42308             :   }
   42309           0 :   arg2 = (pointObj *)(argp2);
   42310             :   {
   42311             :     result = (int)shapeObj_contains__SWIG_1(arg1,arg2); {
   42312           0 :       errorObj *ms_error = msGetErrorObj();
   42313             :       
   42314           0 :       switch(ms_error->code) {
   42315             :       case MS_NOERR:
   42316             :         break;
   42317           0 :       case MS_NOTFOUND:
   42318           0 :         msResetErrorList();
   42319             :         break;
   42320             :       case -1:
   42321             :         break;
   42322           0 :       case MS_IOERR:
   42323           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42324           0 :           _raise_ms_exception();
   42325           0 :           msResetErrorList();
   42326             :           return NULL;
   42327             :         }
   42328             :       default:
   42329           0 :         _raise_ms_exception();
   42330           0 :         msResetErrorList();
   42331             :         return NULL;
   42332             :       }
   42333             :       
   42334             :     }
   42335             :   }
   42336             :   resultobj = SWIG_From_int((int)(result));
   42337             :   return resultobj;
   42338             : fail:
   42339             :   return NULL;
   42340             : }
   42341             : 
   42342             : 
   42343           0 : SWIGINTERN PyObject *_wrap_shapeObj_contains(PyObject *self, PyObject *args) {
   42344             :   Py_ssize_t argc;
   42345           0 :   PyObject *argv[3] = {
   42346             :     0
   42347             :   };
   42348             :   Py_ssize_t ii;
   42349             :   
   42350           0 :   if (!PyTuple_Check(args)) SWIG_fail;
   42351           0 :   argc = args ? PyObject_Length(args) : 0;
   42352           0 :   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
   42353           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
   42354             :   }
   42355           0 :   if (argc == 2) {
   42356             :     int _v;
   42357           0 :     void *vptr = 0;
   42358           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_shapeObj, 0);
   42359             :     _v = SWIG_CheckState(res);
   42360           0 :     if (_v) {
   42361           0 :       void *vptr = 0;
   42362           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_shapeObj, 0);
   42363             :       _v = SWIG_CheckState(res);
   42364           0 :       if (_v) {
   42365           0 :         return _wrap_shapeObj_contains__SWIG_0(self, args);
   42366             :       }
   42367             :     }
   42368             :   }
   42369           0 :   if (argc == 2) {
   42370             :     int _v;
   42371           0 :     void *vptr = 0;
   42372           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_shapeObj, 0);
   42373             :     _v = SWIG_CheckState(res);
   42374           0 :     if (_v) {
   42375           0 :       void *vptr = 0;
   42376           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_pointObj, 0);
   42377             :       _v = SWIG_CheckState(res);
   42378           0 :       if (_v) {
   42379           0 :         return _wrap_shapeObj_contains__SWIG_1(self, args);
   42380             :       }
   42381             :     }
   42382             :   }
   42383             :   
   42384           0 : fail:
   42385           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'shapeObj_contains'.\n"
   42386             :     "  Possible C/C++ prototypes are:\n"
   42387             :     "    shapeObj::contains(shapeObj *)\n"
   42388             :     "    shapeObj::contains(pointObj *)\n");
   42389           0 :   return 0;
   42390             : }
   42391             : 
   42392             : 
   42393           0 : SWIGINTERN PyObject *_wrap_shapeObj_distanceToPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42394             :   PyObject *resultobj = 0;
   42395             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42396             :   pointObj *arg2 = (pointObj *) 0 ;
   42397           0 :   void *argp1 = 0 ;
   42398             :   int res1 = 0 ;
   42399           0 :   void *argp2 = 0 ;
   42400             :   int res2 = 0 ;
   42401           0 :   PyObject * obj0 = 0 ;
   42402           0 :   PyObject * obj1 = 0 ;
   42403             :   double result;
   42404             :   
   42405           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_distanceToPoint",&obj0,&obj1)) SWIG_fail;
   42406           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42407           0 :   if (!SWIG_IsOK(res1)) {
   42408           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_distanceToPoint" "', argument " "1"" of type '" "shapeObj *""'"); 
   42409             :   }
   42410           0 :   arg1 = (shapeObj *)(argp1);
   42411           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   42412           0 :   if (!SWIG_IsOK(res2)) {
   42413           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_distanceToPoint" "', argument " "2"" of type '" "pointObj *""'"); 
   42414             :   }
   42415           0 :   arg2 = (pointObj *)(argp2);
   42416             :   {
   42417             :     result = (double)shapeObj_distanceToPoint(arg1,arg2); {
   42418           0 :       errorObj *ms_error = msGetErrorObj();
   42419             :       
   42420           0 :       switch(ms_error->code) {
   42421             :       case MS_NOERR:
   42422             :         break;
   42423           0 :       case MS_NOTFOUND:
   42424           0 :         msResetErrorList();
   42425           0 :         break;
   42426             :       case -1:
   42427             :         break;
   42428           0 :       case MS_IOERR:
   42429           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42430           0 :           _raise_ms_exception();
   42431           0 :           msResetErrorList();
   42432           0 :           return NULL;
   42433             :         }
   42434             :       default:
   42435           0 :         _raise_ms_exception();
   42436           0 :         msResetErrorList();
   42437           0 :         return NULL;
   42438             :       }
   42439             :       
   42440             :     }
   42441             :   }
   42442           0 :   resultobj = SWIG_From_double((double)(result));
   42443           0 :   return resultobj;
   42444           0 : fail:
   42445             :   return NULL;
   42446             : }
   42447             : 
   42448             : 
   42449           0 : SWIGINTERN PyObject *_wrap_shapeObj_distanceToShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42450             :   PyObject *resultobj = 0;
   42451             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42452             :   shapeObj *arg2 = (shapeObj *) 0 ;
   42453           0 :   void *argp1 = 0 ;
   42454             :   int res1 = 0 ;
   42455           0 :   void *argp2 = 0 ;
   42456             :   int res2 = 0 ;
   42457           0 :   PyObject * obj0 = 0 ;
   42458           0 :   PyObject * obj1 = 0 ;
   42459             :   double result;
   42460             :   
   42461           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_distanceToShape",&obj0,&obj1)) SWIG_fail;
   42462           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42463           0 :   if (!SWIG_IsOK(res1)) {
   42464           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_distanceToShape" "', argument " "1"" of type '" "shapeObj *""'"); 
   42465             :   }
   42466           0 :   arg1 = (shapeObj *)(argp1);
   42467           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   42468           0 :   if (!SWIG_IsOK(res2)) {
   42469           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_distanceToShape" "', argument " "2"" of type '" "shapeObj *""'"); 
   42470             :   }
   42471           0 :   arg2 = (shapeObj *)(argp2);
   42472             :   {
   42473             :     result = (double)shapeObj_distanceToShape(arg1,arg2); {
   42474           0 :       errorObj *ms_error = msGetErrorObj();
   42475             :       
   42476           0 :       switch(ms_error->code) {
   42477             :       case MS_NOERR:
   42478             :         break;
   42479           0 :       case MS_NOTFOUND:
   42480           0 :         msResetErrorList();
   42481           0 :         break;
   42482             :       case -1:
   42483             :         break;
   42484           0 :       case MS_IOERR:
   42485           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42486           0 :           _raise_ms_exception();
   42487           0 :           msResetErrorList();
   42488           0 :           return NULL;
   42489             :         }
   42490             :       default:
   42491           0 :         _raise_ms_exception();
   42492           0 :         msResetErrorList();
   42493           0 :         return NULL;
   42494             :       }
   42495             :       
   42496             :     }
   42497             :   }
   42498           0 :   resultobj = SWIG_From_double((double)(result));
   42499           0 :   return resultobj;
   42500           0 : fail:
   42501             :   return NULL;
   42502             : }
   42503             : 
   42504             : 
   42505           0 : SWIGINTERN PyObject *_wrap_shapeObj_getLabelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42506             :   PyObject *resultobj = 0;
   42507             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42508           0 :   void *argp1 = 0 ;
   42509             :   int res1 = 0 ;
   42510           0 :   PyObject * obj0 = 0 ;
   42511             :   pointObj *result = 0 ;
   42512             :   
   42513           0 :   if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getLabelPoint",&obj0)) SWIG_fail;
   42514           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42515           0 :   if (!SWIG_IsOK(res1)) {
   42516           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getLabelPoint" "', argument " "1"" of type '" "shapeObj *""'"); 
   42517             :   }
   42518           0 :   arg1 = (shapeObj *)(argp1);
   42519             :   {
   42520           0 :     result = (pointObj *)shapeObj_getLabelPoint(arg1); {
   42521           0 :       errorObj *ms_error = msGetErrorObj();
   42522             :       
   42523           0 :       switch(ms_error->code) {
   42524             :       case MS_NOERR:
   42525             :         break;
   42526           0 :       case MS_NOTFOUND:
   42527           0 :         msResetErrorList();
   42528           0 :         break;
   42529             :       case -1:
   42530             :         break;
   42531           0 :       case MS_IOERR:
   42532           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42533           0 :           _raise_ms_exception();
   42534           0 :           msResetErrorList();
   42535           0 :           return NULL;
   42536             :         }
   42537             :       default:
   42538           0 :         _raise_ms_exception();
   42539           0 :         msResetErrorList();
   42540           0 :         return NULL;
   42541             :       }
   42542             :       
   42543             :     }
   42544             :   }
   42545           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_OWN |  0 );
   42546           0 :   return resultobj;
   42547           0 : fail:
   42548             :   return NULL;
   42549             : }
   42550             : 
   42551             : 
   42552           1 : SWIGINTERN PyObject *_wrap_shapeObj_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42553             :   PyObject *resultobj = 0;
   42554             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42555             :   int arg2 ;
   42556             :   char *arg3 = (char *) 0 ;
   42557           1 :   void *argp1 = 0 ;
   42558             :   int res1 = 0 ;
   42559             :   int val2 ;
   42560             :   int ecode2 = 0 ;
   42561             :   int res3 ;
   42562           1 :   char *buf3 = 0 ;
   42563           1 :   int alloc3 = 0 ;
   42564           1 :   PyObject * obj0 = 0 ;
   42565           1 :   PyObject * obj1 = 0 ;
   42566           1 :   PyObject * obj2 = 0 ;
   42567             :   int result;
   42568             :   
   42569           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:shapeObj_setValue",&obj0,&obj1,&obj2)) SWIG_fail;
   42570           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42571           1 :   if (!SWIG_IsOK(res1)) {
   42572           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_setValue" "', argument " "1"" of type '" "shapeObj *""'"); 
   42573             :   }
   42574           1 :   arg1 = (shapeObj *)(argp1);
   42575           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   42576           1 :   if (!SWIG_IsOK(ecode2)) {
   42577           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_setValue" "', argument " "2"" of type '" "int""'");
   42578             :   } 
   42579             :   arg2 = (int)(val2);
   42580           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   42581           1 :   if (!SWIG_IsOK(res3)) {
   42582           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapeObj_setValue" "', argument " "3"" of type '" "char *""'");
   42583             :   }
   42584           1 :   arg3 = (char *)(buf3);
   42585             :   {
   42586           1 :     result = (int)shapeObj_setValue(arg1,arg2,arg3); {
   42587           1 :       errorObj *ms_error = msGetErrorObj();
   42588             :       
   42589           1 :       switch(ms_error->code) {
   42590             :       case MS_NOERR:
   42591             :         break;
   42592           0 :       case MS_NOTFOUND:
   42593           0 :         msResetErrorList();
   42594           0 :         break;
   42595             :       case -1:
   42596             :         break;
   42597           0 :       case MS_IOERR:
   42598           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42599           0 :           _raise_ms_exception();
   42600           0 :           msResetErrorList();
   42601           0 :           return NULL;
   42602             :         }
   42603             :       default:
   42604           0 :         _raise_ms_exception();
   42605           0 :         msResetErrorList();
   42606           0 :         return NULL;
   42607             :       }
   42608             :       
   42609             :     }
   42610             :   }
   42611             :   resultobj = SWIG_From_int((int)(result));
   42612           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   42613             :   return resultobj;
   42614           0 : fail:
   42615           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   42616             :   return NULL;
   42617             : }
   42618             : 
   42619             : 
   42620           1 : SWIGINTERN PyObject *_wrap_shapeObj_initValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42621             :   PyObject *resultobj = 0;
   42622             :   shapeObj *arg1 = (shapeObj *) 0 ;
   42623             :   int arg2 ;
   42624           1 :   void *argp1 = 0 ;
   42625             :   int res1 = 0 ;
   42626             :   int val2 ;
   42627             :   int ecode2 = 0 ;
   42628           1 :   PyObject * obj0 = 0 ;
   42629           1 :   PyObject * obj1 = 0 ;
   42630             :   
   42631           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_initValues",&obj0,&obj1)) SWIG_fail;
   42632           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 |  0 );
   42633           1 :   if (!SWIG_IsOK(res1)) {
   42634           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_initValues" "', argument " "1"" of type '" "shapeObj *""'"); 
   42635             :   }
   42636           1 :   arg1 = (shapeObj *)(argp1);
   42637           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   42638           1 :   if (!SWIG_IsOK(ecode2)) {
   42639           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_initValues" "', argument " "2"" of type '" "int""'");
   42640             :   } 
   42641             :   arg2 = (int)(val2);
   42642             :   {
   42643           1 :     shapeObj_initValues(arg1,arg2); {
   42644           1 :       errorObj *ms_error = msGetErrorObj();
   42645             :       
   42646           1 :       switch(ms_error->code) {
   42647             :       case MS_NOERR:
   42648             :         break;
   42649           0 :       case MS_NOTFOUND:
   42650           0 :         msResetErrorList();
   42651           0 :         break;
   42652             :       case -1:
   42653             :         break;
   42654           0 :       case MS_IOERR:
   42655           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42656           0 :           _raise_ms_exception();
   42657           0 :           msResetErrorList();
   42658           0 :           return NULL;
   42659             :         }
   42660             :       default:
   42661           0 :         _raise_ms_exception();
   42662           0 :         msResetErrorList();
   42663           0 :         return NULL;
   42664             :       }
   42665             :       
   42666             :     }
   42667             :   }
   42668             :   resultobj = SWIG_Py_Void();
   42669           1 :   return resultobj;
   42670           0 : fail:
   42671             :   return NULL;
   42672             : }
   42673             : 
   42674             : 
   42675           1 : SWIGINTERN PyObject *shapeObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42676             :   PyObject *obj;
   42677           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   42678           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_shapeObj, SWIG_NewClientData(obj));
   42679           1 :   return SWIG_Py_Void();
   42680             : }
   42681             : 
   42682           0 : SWIGINTERN PyObject *_wrap_errorObj_code_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42683             :   PyObject *resultobj = 0;
   42684             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42685             :   int arg2 ;
   42686           0 :   void *argp1 = 0 ;
   42687             :   int res1 = 0 ;
   42688             :   int val2 ;
   42689             :   int ecode2 = 0 ;
   42690           0 :   PyObject * obj0 = 0 ;
   42691           0 :   PyObject * obj1 = 0 ;
   42692             :   
   42693           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_code_set",&obj0,&obj1)) SWIG_fail;
   42694           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42695           0 :   if (!SWIG_IsOK(res1)) {
   42696           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_code_set" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42697             :   }
   42698           0 :   arg1 = (struct errorObj *)(argp1);
   42699           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   42700           0 :   if (!SWIG_IsOK(ecode2)) {
   42701           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errorObj_code_set" "', argument " "2"" of type '" "int""'");
   42702             :   } 
   42703             :   arg2 = (int)(val2);
   42704           0 :   if (arg1) (arg1)->code = arg2;
   42705             :   resultobj = SWIG_Py_Void();
   42706           0 :   return resultobj;
   42707           0 : fail:
   42708             :   return NULL;
   42709             : }
   42710             : 
   42711             : 
   42712           0 : SWIGINTERN PyObject *_wrap_errorObj_code_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42713             :   PyObject *resultobj = 0;
   42714             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42715           0 :   void *argp1 = 0 ;
   42716             :   int res1 = 0 ;
   42717           0 :   PyObject * obj0 = 0 ;
   42718             :   int result;
   42719             :   
   42720           0 :   if (!PyArg_ParseTuple(args,(char *)"O:errorObj_code_get",&obj0)) SWIG_fail;
   42721           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42722           0 :   if (!SWIG_IsOK(res1)) {
   42723           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_code_get" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42724             :   }
   42725           0 :   arg1 = (struct errorObj *)(argp1);
   42726           0 :   result = (int) ((arg1)->code);
   42727             :   resultobj = SWIG_From_int((int)(result));
   42728           0 :   return resultobj;
   42729           0 : fail:
   42730             :   return NULL;
   42731             : }
   42732             : 
   42733             : 
   42734           0 : SWIGINTERN PyObject *_wrap_errorObj_routine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42735             :   PyObject *resultobj = 0;
   42736             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42737             :   char *arg2 ;
   42738           0 :   void *argp1 = 0 ;
   42739             :   int res1 = 0 ;
   42740             :   char temp2[64] ;
   42741             :   int res2 ;
   42742           0 :   PyObject * obj0 = 0 ;
   42743           0 :   PyObject * obj1 = 0 ;
   42744             :   
   42745           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_routine_set",&obj0,&obj1)) SWIG_fail;
   42746           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42747           0 :   if (!SWIG_IsOK(res1)) {
   42748           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_routine_set" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42749             :   }
   42750           0 :   arg1 = (struct errorObj *)(argp1);
   42751           0 :   res2 = SWIG_AsCharArray(obj1, temp2, 64);
   42752           0 :   if (!SWIG_IsOK(res2)) {
   42753           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "errorObj_routine_set" "', argument " "2"" of type '" "char [64]""'");
   42754             :   }
   42755             :   arg2 = (char *)(temp2);
   42756           0 :   if (arg2) memcpy(arg1->routine,arg2,64*sizeof(char));
   42757             :   else memset(arg1->routine,0,64*sizeof(char));
   42758             :   resultobj = SWIG_Py_Void();
   42759           0 :   return resultobj;
   42760           0 : fail:
   42761             :   return NULL;
   42762             : }
   42763             : 
   42764             : 
   42765           0 : SWIGINTERN PyObject *_wrap_errorObj_routine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42766             :   PyObject *resultobj = 0;
   42767             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42768           0 :   void *argp1 = 0 ;
   42769             :   int res1 = 0 ;
   42770           0 :   PyObject * obj0 = 0 ;
   42771             :   char *result = 0 ;
   42772             :   
   42773           0 :   if (!PyArg_ParseTuple(args,(char *)"O:errorObj_routine_get",&obj0)) SWIG_fail;
   42774           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42775           0 :   if (!SWIG_IsOK(res1)) {
   42776           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_routine_get" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42777             :   }
   42778           0 :   arg1 = (struct errorObj *)(argp1);
   42779           0 :   result = (char *)(char *) ((arg1)->routine);
   42780             :   {
   42781             :     size_t size = SWIG_strnlen(result, 64);
   42782             :     
   42783             :     
   42784             :     
   42785           0 :     resultobj = SWIG_FromCharPtrAndSize(result, size);
   42786             :   }
   42787           0 :   return resultobj;
   42788           0 : fail:
   42789             :   return NULL;
   42790             : }
   42791             : 
   42792             : 
   42793           0 : SWIGINTERN PyObject *_wrap_errorObj_message_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42794             :   PyObject *resultobj = 0;
   42795             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42796             :   char *arg2 ;
   42797           0 :   void *argp1 = 0 ;
   42798             :   int res1 = 0 ;
   42799             :   char temp2[2048] ;
   42800             :   int res2 ;
   42801           0 :   PyObject * obj0 = 0 ;
   42802           0 :   PyObject * obj1 = 0 ;
   42803             :   
   42804           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_message_set",&obj0,&obj1)) SWIG_fail;
   42805           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42806           0 :   if (!SWIG_IsOK(res1)) {
   42807           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_message_set" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42808             :   }
   42809           0 :   arg1 = (struct errorObj *)(argp1);
   42810           0 :   res2 = SWIG_AsCharArray(obj1, temp2, 2048);
   42811           0 :   if (!SWIG_IsOK(res2)) {
   42812           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "errorObj_message_set" "', argument " "2"" of type '" "char [2048]""'");
   42813             :   }
   42814             :   arg2 = (char *)(temp2);
   42815           0 :   if (arg2) memcpy(arg1->message,arg2,2048*sizeof(char));
   42816             :   else memset(arg1->message,0,2048*sizeof(char));
   42817             :   resultobj = SWIG_Py_Void();
   42818           0 :   return resultobj;
   42819           0 : fail:
   42820             :   return NULL;
   42821             : }
   42822             : 
   42823             : 
   42824           0 : SWIGINTERN PyObject *_wrap_errorObj_message_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42825             :   PyObject *resultobj = 0;
   42826             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42827           0 :   void *argp1 = 0 ;
   42828             :   int res1 = 0 ;
   42829           0 :   PyObject * obj0 = 0 ;
   42830             :   char *result = 0 ;
   42831             :   
   42832           0 :   if (!PyArg_ParseTuple(args,(char *)"O:errorObj_message_get",&obj0)) SWIG_fail;
   42833           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42834           0 :   if (!SWIG_IsOK(res1)) {
   42835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_message_get" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42836             :   }
   42837           0 :   arg1 = (struct errorObj *)(argp1);
   42838           0 :   result = (char *)(char *) ((arg1)->message);
   42839             :   {
   42840             :     size_t size = SWIG_strnlen(result, 2048);
   42841             :     
   42842             :     
   42843             :     
   42844           0 :     resultobj = SWIG_FromCharPtrAndSize(result, size);
   42845             :   }
   42846           0 :   return resultobj;
   42847           0 : fail:
   42848             :   return NULL;
   42849             : }
   42850             : 
   42851             : 
   42852           0 : SWIGINTERN PyObject *_wrap_errorObj_isreported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42853             :   PyObject *resultobj = 0;
   42854             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42855             :   int arg2 ;
   42856           0 :   void *argp1 = 0 ;
   42857             :   int res1 = 0 ;
   42858             :   int val2 ;
   42859             :   int ecode2 = 0 ;
   42860           0 :   PyObject * obj0 = 0 ;
   42861           0 :   PyObject * obj1 = 0 ;
   42862             :   
   42863           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_isreported_set",&obj0,&obj1)) SWIG_fail;
   42864           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42865           0 :   if (!SWIG_IsOK(res1)) {
   42866           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_isreported_set" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42867             :   }
   42868           0 :   arg1 = (struct errorObj *)(argp1);
   42869           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   42870           0 :   if (!SWIG_IsOK(ecode2)) {
   42871           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errorObj_isreported_set" "', argument " "2"" of type '" "int""'");
   42872             :   } 
   42873             :   arg2 = (int)(val2);
   42874           0 :   if (arg1) (arg1)->isreported = arg2;
   42875             :   resultobj = SWIG_Py_Void();
   42876           0 :   return resultobj;
   42877           0 : fail:
   42878             :   return NULL;
   42879             : }
   42880             : 
   42881             : 
   42882           0 : SWIGINTERN PyObject *_wrap_errorObj_isreported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42883             :   PyObject *resultobj = 0;
   42884             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42885           0 :   void *argp1 = 0 ;
   42886             :   int res1 = 0 ;
   42887           0 :   PyObject * obj0 = 0 ;
   42888             :   int result;
   42889             :   
   42890           0 :   if (!PyArg_ParseTuple(args,(char *)"O:errorObj_isreported_get",&obj0)) SWIG_fail;
   42891           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42892           0 :   if (!SWIG_IsOK(res1)) {
   42893           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_isreported_get" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42894             :   }
   42895           0 :   arg1 = (struct errorObj *)(argp1);
   42896           0 :   result = (int) ((arg1)->isreported);
   42897             :   resultobj = SWIG_From_int((int)(result));
   42898           0 :   return resultobj;
   42899           0 : fail:
   42900             :   return NULL;
   42901             : }
   42902             : 
   42903             : 
   42904           0 : SWIGINTERN PyObject *_wrap_errorObj_errorcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42905             :   PyObject *resultobj = 0;
   42906             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42907             :   int arg2 ;
   42908           0 :   void *argp1 = 0 ;
   42909             :   int res1 = 0 ;
   42910             :   int val2 ;
   42911             :   int ecode2 = 0 ;
   42912           0 :   PyObject * obj0 = 0 ;
   42913           0 :   PyObject * obj1 = 0 ;
   42914             :   
   42915           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_errorcount_set",&obj0,&obj1)) SWIG_fail;
   42916           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42917           0 :   if (!SWIG_IsOK(res1)) {
   42918           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_errorcount_set" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42919             :   }
   42920           0 :   arg1 = (struct errorObj *)(argp1);
   42921           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   42922           0 :   if (!SWIG_IsOK(ecode2)) {
   42923           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errorObj_errorcount_set" "', argument " "2"" of type '" "int""'");
   42924             :   } 
   42925             :   arg2 = (int)(val2);
   42926           0 :   if (arg1) (arg1)->errorcount = arg2;
   42927             :   resultobj = SWIG_Py_Void();
   42928           0 :   return resultobj;
   42929           0 : fail:
   42930             :   return NULL;
   42931             : }
   42932             : 
   42933             : 
   42934           0 : SWIGINTERN PyObject *_wrap_errorObj_errorcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42935             :   PyObject *resultobj = 0;
   42936             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42937           0 :   void *argp1 = 0 ;
   42938             :   int res1 = 0 ;
   42939           0 :   PyObject * obj0 = 0 ;
   42940             :   int result;
   42941             :   
   42942           0 :   if (!PyArg_ParseTuple(args,(char *)"O:errorObj_errorcount_get",&obj0)) SWIG_fail;
   42943           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   42944           0 :   if (!SWIG_IsOK(res1)) {
   42945           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_errorcount_get" "', argument " "1"" of type '" "struct errorObj *""'"); 
   42946             :   }
   42947           0 :   arg1 = (struct errorObj *)(argp1);
   42948           0 :   result = (int) ((arg1)->errorcount);
   42949             :   resultobj = SWIG_From_int((int)(result));
   42950           0 :   return resultobj;
   42951           0 : fail:
   42952             :   return NULL;
   42953             : }
   42954             : 
   42955             : 
   42956           0 : SWIGINTERN PyObject *_wrap_new_errorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42957             :   PyObject *resultobj = 0;
   42958             :   struct errorObj *result = 0 ;
   42959             :   
   42960           0 :   if (!PyArg_ParseTuple(args,(char *)":new_errorObj")) SWIG_fail;
   42961             :   {
   42962             :     result = (struct errorObj *)new_errorObj(); {
   42963           0 :       errorObj *ms_error = msGetErrorObj();
   42964             :       
   42965           0 :       switch(ms_error->code) {
   42966             :       case MS_NOERR:
   42967             :         break;
   42968           0 :       case MS_NOTFOUND:
   42969           0 :         msResetErrorList();
   42970           0 :         break;
   42971             :       case -1:
   42972             :         break;
   42973           0 :       case MS_IOERR:
   42974           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   42975           0 :           _raise_ms_exception();
   42976           0 :           msResetErrorList();
   42977           0 :           return NULL;
   42978             :         }
   42979             :       default:
   42980           0 :         _raise_ms_exception();
   42981           0 :         msResetErrorList();
   42982           0 :         return NULL;
   42983             :       }
   42984             :       
   42985             :     }
   42986             :   }
   42987           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_errorObj, SWIG_POINTER_NEW |  0 );
   42988           0 :   return resultobj;
   42989           0 : fail:
   42990             :   return NULL;
   42991             : }
   42992             : 
   42993             : 
   42994           0 : SWIGINTERN PyObject *_wrap_delete_errorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   42995             :   PyObject *resultobj = 0;
   42996             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   42997           0 :   void *argp1 = 0 ;
   42998             :   int res1 = 0 ;
   42999           0 :   PyObject * obj0 = 0 ;
   43000             :   
   43001           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_errorObj",&obj0)) SWIG_fail;
   43002           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, SWIG_POINTER_DISOWN |  0 );
   43003           0 :   if (!SWIG_IsOK(res1)) {
   43004           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_errorObj" "', argument " "1"" of type '" "struct errorObj *""'"); 
   43005             :   }
   43006             :   arg1 = (struct errorObj *)(argp1);
   43007             :   {
   43008             :     delete_errorObj(arg1); {
   43009           0 :       errorObj *ms_error = msGetErrorObj();
   43010             :       
   43011           0 :       switch(ms_error->code) {
   43012             :       case MS_NOERR:
   43013             :         break;
   43014           0 :       case MS_NOTFOUND:
   43015           0 :         msResetErrorList();
   43016           0 :         break;
   43017             :       case -1:
   43018             :         break;
   43019           0 :       case MS_IOERR:
   43020           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43021           0 :           _raise_ms_exception();
   43022           0 :           msResetErrorList();
   43023           0 :           return NULL;
   43024             :         }
   43025             :       default:
   43026           0 :         _raise_ms_exception();
   43027           0 :         msResetErrorList();
   43028           0 :         return NULL;
   43029             :       }
   43030             :       
   43031             :     }
   43032             :   }
   43033             :   resultobj = SWIG_Py_Void();
   43034           0 :   return resultobj;
   43035           0 : fail:
   43036             :   return NULL;
   43037             : }
   43038             : 
   43039             : 
   43040           0 : SWIGINTERN PyObject *_wrap_errorObj_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43041             :   PyObject *resultobj = 0;
   43042             :   struct errorObj *arg1 = (struct errorObj *) 0 ;
   43043           0 :   void *argp1 = 0 ;
   43044             :   int res1 = 0 ;
   43045           0 :   PyObject * obj0 = 0 ;
   43046             :   errorObj *result = 0 ;
   43047             :   
   43048           0 :   if (!PyArg_ParseTuple(args,(char *)"O:errorObj_next",&obj0)) SWIG_fail;
   43049           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 |  0 );
   43050           0 :   if (!SWIG_IsOK(res1)) {
   43051           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_next" "', argument " "1"" of type '" "struct errorObj *""'"); 
   43052             :   }
   43053           0 :   arg1 = (struct errorObj *)(argp1);
   43054             :   {
   43055           0 :     result = (errorObj *)errorObj_next(arg1); {
   43056           0 :       errorObj *ms_error = msGetErrorObj();
   43057             :       
   43058           0 :       switch(ms_error->code) {
   43059             :       case MS_NOERR:
   43060             :         break;
   43061           0 :       case MS_NOTFOUND:
   43062           0 :         msResetErrorList();
   43063           0 :         break;
   43064             :       case -1:
   43065             :         break;
   43066           0 :       case MS_IOERR:
   43067           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43068           0 :           _raise_ms_exception();
   43069           0 :           msResetErrorList();
   43070           0 :           return NULL;
   43071             :         }
   43072             :       default:
   43073           0 :         _raise_ms_exception();
   43074           0 :         msResetErrorList();
   43075           0 :         return NULL;
   43076             :       }
   43077             :       
   43078             :     }
   43079             :   }
   43080           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_errorObj, 0 |  0 );
   43081           0 :   return resultobj;
   43082           0 : fail:
   43083             :   return NULL;
   43084             : }
   43085             : 
   43086             : 
   43087           1 : SWIGINTERN PyObject *errorObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43088             :   PyObject *obj;
   43089           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   43090           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_errorObj, SWIG_NewClientData(obj));
   43091           1 :   return SWIG_Py_Void();
   43092             : }
   43093             : 
   43094           0 : SWIGINTERN PyObject *_wrap_msGetErrorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43095             :   PyObject *resultobj = 0;
   43096             :   errorObj *result = 0 ;
   43097             :   
   43098           0 :   if (!PyArg_ParseTuple(args,(char *)":msGetErrorObj")) SWIG_fail;
   43099             :   {
   43100           0 :     result = (errorObj *)msGetErrorObj(); {
   43101           0 :       errorObj *ms_error = msGetErrorObj();
   43102             :       
   43103           0 :       switch(ms_error->code) {
   43104             :       case MS_NOERR:
   43105             :         break;
   43106           0 :       case MS_NOTFOUND:
   43107           0 :         msResetErrorList();
   43108           0 :         break;
   43109             :       case -1:
   43110             :         break;
   43111           0 :       case MS_IOERR:
   43112           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43113           0 :           _raise_ms_exception();
   43114           0 :           msResetErrorList();
   43115           0 :           return NULL;
   43116             :         }
   43117             :       default:
   43118           0 :         _raise_ms_exception();
   43119           0 :         msResetErrorList();
   43120           0 :         return NULL;
   43121             :       }
   43122             :       
   43123             :     }
   43124             :   }
   43125           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_errorObj, 0 |  0 );
   43126           0 :   return resultobj;
   43127           0 : fail:
   43128             :   return NULL;
   43129             : }
   43130             : 
   43131             : 
   43132           0 : SWIGINTERN PyObject *_wrap_msResetErrorList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43133             :   PyObject *resultobj = 0;
   43134             :   
   43135           0 :   if (!PyArg_ParseTuple(args,(char *)":msResetErrorList")) SWIG_fail;
   43136             :   {
   43137           0 :     msResetErrorList(); {
   43138           0 :       errorObj *ms_error = msGetErrorObj();
   43139             :       
   43140           0 :       switch(ms_error->code) {
   43141             :       case MS_NOERR:
   43142             :         break;
   43143           0 :       case MS_NOTFOUND:
   43144           0 :         msResetErrorList();
   43145           0 :         break;
   43146             :       case -1:
   43147             :         break;
   43148           0 :       case MS_IOERR:
   43149           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43150           0 :           _raise_ms_exception();
   43151           0 :           msResetErrorList();
   43152           0 :           return NULL;
   43153             :         }
   43154             :       default:
   43155           0 :         _raise_ms_exception();
   43156           0 :         msResetErrorList();
   43157           0 :         return NULL;
   43158             :       }
   43159             :       
   43160             :     }
   43161             :   }
   43162             :   resultobj = SWIG_Py_Void();
   43163           0 :   return resultobj;
   43164           0 : fail:
   43165             :   return NULL;
   43166             : }
   43167             : 
   43168             : 
   43169           1 : SWIGINTERN PyObject *_wrap_msGetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43170             :   PyObject *resultobj = 0;
   43171             :   char *result = 0 ;
   43172             :   
   43173           1 :   if (!PyArg_ParseTuple(args,(char *)":msGetVersion")) SWIG_fail;
   43174             :   {
   43175           1 :     result = (char *)msGetVersion(); {
   43176           1 :       errorObj *ms_error = msGetErrorObj();
   43177             :       
   43178           1 :       switch(ms_error->code) {
   43179             :       case MS_NOERR:
   43180             :         break;
   43181           0 :       case MS_NOTFOUND:
   43182           0 :         msResetErrorList();
   43183           0 :         break;
   43184             :       case -1:
   43185             :         break;
   43186           0 :       case MS_IOERR:
   43187           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43188           0 :           _raise_ms_exception();
   43189           0 :           msResetErrorList();
   43190           0 :           return NULL;
   43191             :         }
   43192             :       default:
   43193           0 :         _raise_ms_exception();
   43194           0 :         msResetErrorList();
   43195           0 :         return NULL;
   43196             :       }
   43197             :       
   43198             :     }
   43199             :   }
   43200           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   43201           1 :   return resultobj;
   43202           1 : fail:
   43203             :   return NULL;
   43204             : }
   43205             : 
   43206             : 
   43207           0 : SWIGINTERN PyObject *_wrap_msGetVersionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43208             :   PyObject *resultobj = 0;
   43209             :   int result;
   43210             :   
   43211           0 :   if (!PyArg_ParseTuple(args,(char *)":msGetVersionInt")) SWIG_fail;
   43212             :   {
   43213           0 :     result = (int)msGetVersionInt(); {
   43214           0 :       errorObj *ms_error = msGetErrorObj();
   43215             :       
   43216           0 :       switch(ms_error->code) {
   43217             :       case MS_NOERR:
   43218             :         break;
   43219           0 :       case MS_NOTFOUND:
   43220           0 :         msResetErrorList();
   43221           0 :         break;
   43222             :       case -1:
   43223             :         break;
   43224           0 :       case MS_IOERR:
   43225           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43226           0 :           _raise_ms_exception();
   43227           0 :           msResetErrorList();
   43228           0 :           return NULL;
   43229             :         }
   43230             :       default:
   43231           0 :         _raise_ms_exception();
   43232           0 :         msResetErrorList();
   43233           0 :         return NULL;
   43234             :       }
   43235             :       
   43236             :     }
   43237             :   }
   43238             :   resultobj = SWIG_From_int((int)(result));
   43239           0 :   return resultobj;
   43240           0 : fail:
   43241             :   return NULL;
   43242             : }
   43243             : 
   43244             : 
   43245           0 : SWIGINTERN PyObject *_wrap_msGetErrorString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43246             :   PyObject *resultobj = 0;
   43247             :   char *arg1 = (char *) 0 ;
   43248             :   int res1 ;
   43249           0 :   char *buf1 = 0 ;
   43250           0 :   int alloc1 = 0 ;
   43251           0 :   PyObject * obj0 = 0 ;
   43252             :   char *result = 0 ;
   43253             :   
   43254           0 :   if (!PyArg_ParseTuple(args,(char *)"O:msGetErrorString",&obj0)) SWIG_fail;
   43255           0 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   43256           0 :   if (!SWIG_IsOK(res1)) {
   43257           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msGetErrorString" "', argument " "1"" of type '" "char const *""'");
   43258             :   }
   43259           0 :   arg1 = (char *)(buf1);
   43260             :   {
   43261           0 :     result = (char *)msGetErrorString((char const *)arg1); {
   43262           0 :       errorObj *ms_error = msGetErrorObj();
   43263             :       
   43264           0 :       switch(ms_error->code) {
   43265             :       case MS_NOERR:
   43266             :         break;
   43267           0 :       case MS_NOTFOUND:
   43268           0 :         msResetErrorList();
   43269           0 :         break;
   43270             :       case -1:
   43271             :         break;
   43272           0 :       case MS_IOERR:
   43273           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43274           0 :           _raise_ms_exception();
   43275           0 :           msResetErrorList();
   43276           0 :           return NULL;
   43277             :         }
   43278             :       default:
   43279           0 :         _raise_ms_exception();
   43280           0 :         msResetErrorList();
   43281           0 :         return NULL;
   43282             :       }
   43283             :       
   43284             :     }
   43285             :   }
   43286           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   43287           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   43288             :   return resultobj;
   43289           0 : fail:
   43290           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   43291             :   return NULL;
   43292             : }
   43293             : 
   43294             : 
   43295           1 : SWIGINTERN PyObject *_wrap_DBFInfo_nRecords_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43296             :   PyObject *resultobj = 0;
   43297             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43298           1 :   void *argp1 = 0 ;
   43299             :   int res1 = 0 ;
   43300           1 :   PyObject * obj0 = 0 ;
   43301             :   int result;
   43302             :   
   43303           1 :   if (!PyArg_ParseTuple(args,(char *)"O:DBFInfo_nRecords_get",&obj0)) SWIG_fail;
   43304           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 |  0 );
   43305           1 :   if (!SWIG_IsOK(res1)) {
   43306           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_nRecords_get" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43307             :   }
   43308           1 :   arg1 = (DBFInfo *)(argp1);
   43309           1 :   result = (int) ((arg1)->nRecords);
   43310             :   resultobj = SWIG_From_int((int)(result));
   43311           1 :   return resultobj;
   43312           0 : fail:
   43313             :   return NULL;
   43314             : }
   43315             : 
   43316             : 
   43317           1 : SWIGINTERN PyObject *_wrap_DBFInfo_nFields_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43318             :   PyObject *resultobj = 0;
   43319             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43320           1 :   void *argp1 = 0 ;
   43321             :   int res1 = 0 ;
   43322           1 :   PyObject * obj0 = 0 ;
   43323             :   int result;
   43324             :   
   43325           1 :   if (!PyArg_ParseTuple(args,(char *)"O:DBFInfo_nFields_get",&obj0)) SWIG_fail;
   43326           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 |  0 );
   43327           1 :   if (!SWIG_IsOK(res1)) {
   43328           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_nFields_get" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43329             :   }
   43330           1 :   arg1 = (DBFInfo *)(argp1);
   43331           1 :   result = (int) ((arg1)->nFields);
   43332             :   resultobj = SWIG_From_int((int)(result));
   43333           1 :   return resultobj;
   43334           0 : fail:
   43335             :   return NULL;
   43336             : }
   43337             : 
   43338             : 
   43339           1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43340             :   PyObject *resultobj = 0;
   43341             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43342             :   int arg2 ;
   43343           1 :   void *argp1 = 0 ;
   43344             :   int res1 = 0 ;
   43345             :   int val2 ;
   43346             :   int ecode2 = 0 ;
   43347           1 :   PyObject * obj0 = 0 ;
   43348           1 :   PyObject * obj1 = 0 ;
   43349             :   char *result = 0 ;
   43350             :   
   43351           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldName",&obj0,&obj1)) SWIG_fail;
   43352           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 |  0 );
   43353           1 :   if (!SWIG_IsOK(res1)) {
   43354           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldName" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43355             :   }
   43356           1 :   arg1 = (DBFInfo *)(argp1);
   43357           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43358           1 :   if (!SWIG_IsOK(ecode2)) {
   43359           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldName" "', argument " "2"" of type '" "int""'");
   43360             :   } 
   43361             :   arg2 = (int)(val2);
   43362             :   {
   43363             :     result = (char *)DBFInfo_getFieldName(arg1,arg2); {
   43364           1 :       errorObj *ms_error = msGetErrorObj();
   43365             :       
   43366           1 :       switch(ms_error->code) {
   43367             :       case MS_NOERR:
   43368             :         break;
   43369           0 :       case MS_NOTFOUND:
   43370           0 :         msResetErrorList();
   43371           0 :         break;
   43372             :       case -1:
   43373             :         break;
   43374           0 :       case MS_IOERR:
   43375           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43376           0 :           _raise_ms_exception();
   43377           0 :           msResetErrorList();
   43378           0 :           return NULL;
   43379             :         }
   43380             :       default:
   43381           0 :         _raise_ms_exception();
   43382           0 :         msResetErrorList();
   43383           0 :         return NULL;
   43384             :       }
   43385             :       
   43386             :     }
   43387             :   }
   43388           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   43389           1 :   return resultobj;
   43390           0 : fail:
   43391             :   return NULL;
   43392             : }
   43393             : 
   43394             : 
   43395           1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43396             :   PyObject *resultobj = 0;
   43397             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43398             :   int arg2 ;
   43399           1 :   void *argp1 = 0 ;
   43400             :   int res1 = 0 ;
   43401             :   int val2 ;
   43402             :   int ecode2 = 0 ;
   43403           1 :   PyObject * obj0 = 0 ;
   43404           1 :   PyObject * obj1 = 0 ;
   43405             :   int result;
   43406             :   
   43407           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldWidth",&obj0,&obj1)) SWIG_fail;
   43408           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 |  0 );
   43409           1 :   if (!SWIG_IsOK(res1)) {
   43410           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldWidth" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43411             :   }
   43412           1 :   arg1 = (DBFInfo *)(argp1);
   43413           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43414           1 :   if (!SWIG_IsOK(ecode2)) {
   43415           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldWidth" "', argument " "2"" of type '" "int""'");
   43416             :   } 
   43417             :   arg2 = (int)(val2);
   43418             :   {
   43419           1 :     result = (int)DBFInfo_getFieldWidth(arg1,arg2); {
   43420           1 :       errorObj *ms_error = msGetErrorObj();
   43421             :       
   43422           1 :       switch(ms_error->code) {
   43423             :       case MS_NOERR:
   43424             :         break;
   43425           0 :       case MS_NOTFOUND:
   43426           0 :         msResetErrorList();
   43427           0 :         break;
   43428             :       case -1:
   43429             :         break;
   43430           0 :       case MS_IOERR:
   43431           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43432           0 :           _raise_ms_exception();
   43433           0 :           msResetErrorList();
   43434           0 :           return NULL;
   43435             :         }
   43436             :       default:
   43437           0 :         _raise_ms_exception();
   43438           0 :         msResetErrorList();
   43439           0 :         return NULL;
   43440             :       }
   43441             :       
   43442             :     }
   43443             :   }
   43444             :   resultobj = SWIG_From_int((int)(result));
   43445           1 :   return resultobj;
   43446           0 : fail:
   43447             :   return NULL;
   43448             : }
   43449             : 
   43450             : 
   43451           1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldDecimals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43452             :   PyObject *resultobj = 0;
   43453             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43454             :   int arg2 ;
   43455           1 :   void *argp1 = 0 ;
   43456             :   int res1 = 0 ;
   43457             :   int val2 ;
   43458             :   int ecode2 = 0 ;
   43459           1 :   PyObject * obj0 = 0 ;
   43460           1 :   PyObject * obj1 = 0 ;
   43461             :   int result;
   43462             :   
   43463           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldDecimals",&obj0,&obj1)) SWIG_fail;
   43464           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 |  0 );
   43465           1 :   if (!SWIG_IsOK(res1)) {
   43466           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldDecimals" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43467             :   }
   43468           1 :   arg1 = (DBFInfo *)(argp1);
   43469           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43470           1 :   if (!SWIG_IsOK(ecode2)) {
   43471           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldDecimals" "', argument " "2"" of type '" "int""'");
   43472             :   } 
   43473             :   arg2 = (int)(val2);
   43474             :   {
   43475           1 :     result = (int)DBFInfo_getFieldDecimals(arg1,arg2); {
   43476           1 :       errorObj *ms_error = msGetErrorObj();
   43477             :       
   43478           1 :       switch(ms_error->code) {
   43479             :       case MS_NOERR:
   43480             :         break;
   43481           0 :       case MS_NOTFOUND:
   43482           0 :         msResetErrorList();
   43483           0 :         break;
   43484             :       case -1:
   43485             :         break;
   43486           0 :       case MS_IOERR:
   43487           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43488           0 :           _raise_ms_exception();
   43489           0 :           msResetErrorList();
   43490           0 :           return NULL;
   43491             :         }
   43492             :       default:
   43493           0 :         _raise_ms_exception();
   43494           0 :         msResetErrorList();
   43495           0 :         return NULL;
   43496             :       }
   43497             :       
   43498             :     }
   43499             :   }
   43500             :   resultobj = SWIG_From_int((int)(result));
   43501           1 :   return resultobj;
   43502           0 : fail:
   43503             :   return NULL;
   43504             : }
   43505             : 
   43506             : 
   43507           1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43508             :   PyObject *resultobj = 0;
   43509             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43510             :   int arg2 ;
   43511           1 :   void *argp1 = 0 ;
   43512             :   int res1 = 0 ;
   43513             :   int val2 ;
   43514             :   int ecode2 = 0 ;
   43515           1 :   PyObject * obj0 = 0 ;
   43516           1 :   PyObject * obj1 = 0 ;
   43517             :   int result;
   43518             :   
   43519           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldType",&obj0,&obj1)) SWIG_fail;
   43520           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 |  0 );
   43521           1 :   if (!SWIG_IsOK(res1)) {
   43522           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldType" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43523             :   }
   43524           1 :   arg1 = (DBFInfo *)(argp1);
   43525           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43526           1 :   if (!SWIG_IsOK(ecode2)) {
   43527           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldType" "', argument " "2"" of type '" "int""'");
   43528             :   } 
   43529             :   arg2 = (int)(val2);
   43530             :   {
   43531             :     result = (int)DBFInfo_getFieldType(arg1,arg2); {
   43532           1 :       errorObj *ms_error = msGetErrorObj();
   43533             :       
   43534           1 :       switch(ms_error->code) {
   43535             :       case MS_NOERR:
   43536             :         break;
   43537           0 :       case MS_NOTFOUND:
   43538           0 :         msResetErrorList();
   43539           0 :         break;
   43540             :       case -1:
   43541             :         break;
   43542           0 :       case MS_IOERR:
   43543           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43544           0 :           _raise_ms_exception();
   43545           0 :           msResetErrorList();
   43546           0 :           return NULL;
   43547             :         }
   43548             :       default:
   43549           0 :         _raise_ms_exception();
   43550           0 :         msResetErrorList();
   43551           0 :         return NULL;
   43552             :       }
   43553             :       
   43554             :     }
   43555             :   }
   43556             :   resultobj = SWIG_From_int((int)(result));
   43557           1 :   return resultobj;
   43558           0 : fail:
   43559             :   return NULL;
   43560             : }
   43561             : 
   43562             : 
   43563           0 : SWIGINTERN PyObject *_wrap_new_DBFInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43564             :   PyObject *resultobj = 0;
   43565             :   DBFInfo *result = 0 ;
   43566             :   
   43567           0 :   if (!PyArg_ParseTuple(args,(char *)":new_DBFInfo")) SWIG_fail;
   43568             :   {
   43569           0 :     result = (DBFInfo *)calloc(1, sizeof(DBFInfo)); {
   43570           0 :       errorObj *ms_error = msGetErrorObj();
   43571             :       
   43572           0 :       switch(ms_error->code) {
   43573             :       case MS_NOERR:
   43574             :         break;
   43575           0 :       case MS_NOTFOUND:
   43576           0 :         msResetErrorList();
   43577           0 :         break;
   43578             :       case -1:
   43579             :         break;
   43580           0 :       case MS_IOERR:
   43581           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43582           0 :           _raise_ms_exception();
   43583           0 :           msResetErrorList();
   43584           0 :           return NULL;
   43585             :         }
   43586             :       default:
   43587           0 :         _raise_ms_exception();
   43588           0 :         msResetErrorList();
   43589           0 :         return NULL;
   43590             :       }
   43591             :       
   43592             :     }
   43593             :   }
   43594           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DBFInfo, SWIG_POINTER_NEW |  0 );
   43595           0 :   return resultobj;
   43596           0 : fail:
   43597             :   return NULL;
   43598             : }
   43599             : 
   43600             : 
   43601           0 : SWIGINTERN PyObject *_wrap_delete_DBFInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43602             :   PyObject *resultobj = 0;
   43603             :   DBFInfo *arg1 = (DBFInfo *) 0 ;
   43604           0 :   void *argp1 = 0 ;
   43605             :   int res1 = 0 ;
   43606           0 :   PyObject * obj0 = 0 ;
   43607             :   
   43608           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_DBFInfo",&obj0)) SWIG_fail;
   43609           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, SWIG_POINTER_DISOWN |  0 );
   43610           0 :   if (!SWIG_IsOK(res1)) {
   43611           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DBFInfo" "', argument " "1"" of type '" "DBFInfo *""'"); 
   43612             :   }
   43613           0 :   arg1 = (DBFInfo *)(argp1);
   43614             :   {
   43615           0 :     free((char *) arg1); {
   43616           0 :       errorObj *ms_error = msGetErrorObj();
   43617             :       
   43618           0 :       switch(ms_error->code) {
   43619             :       case MS_NOERR:
   43620             :         break;
   43621           0 :       case MS_NOTFOUND:
   43622           0 :         msResetErrorList();
   43623           0 :         break;
   43624             :       case -1:
   43625             :         break;
   43626           0 :       case MS_IOERR:
   43627           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43628           0 :           _raise_ms_exception();
   43629           0 :           msResetErrorList();
   43630           0 :           return NULL;
   43631             :         }
   43632             :       default:
   43633           0 :         _raise_ms_exception();
   43634           0 :         msResetErrorList();
   43635           0 :         return NULL;
   43636             :       }
   43637             :       
   43638             :     }
   43639             :   }
   43640             :   resultobj = SWIG_Py_Void();
   43641           0 :   return resultobj;
   43642           0 : fail:
   43643             :   return NULL;
   43644             : }
   43645             : 
   43646             : 
   43647           1 : SWIGINTERN PyObject *DBFInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43648             :   PyObject *obj;
   43649           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   43650           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_DBFInfo, SWIG_NewClientData(obj));
   43651           1 :   return SWIG_Py_Void();
   43652             : }
   43653             : 
   43654           1 : SWIGINTERN PyObject *_wrap_shapefileObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43655             :   PyObject *resultobj = 0;
   43656             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43657           1 :   void *argp1 = 0 ;
   43658             :   int res1 = 0 ;
   43659           1 :   PyObject * obj0 = 0 ;
   43660             :   int result;
   43661             :   
   43662           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_type_get",&obj0)) SWIG_fail;
   43663           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   43664           1 :   if (!SWIG_IsOK(res1)) {
   43665           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_type_get" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43666             :   }
   43667           1 :   arg1 = (shapefileObj *)(argp1);
   43668           1 :   result = (int) ((arg1)->type);
   43669             :   resultobj = SWIG_From_int((int)(result));
   43670           1 :   return resultobj;
   43671           0 : fail:
   43672             :   return NULL;
   43673             : }
   43674             : 
   43675             : 
   43676           1 : SWIGINTERN PyObject *_wrap_shapefileObj_numshapes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43677             :   PyObject *resultobj = 0;
   43678             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43679           1 :   void *argp1 = 0 ;
   43680             :   int res1 = 0 ;
   43681           1 :   PyObject * obj0 = 0 ;
   43682             :   int result;
   43683             :   
   43684           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_numshapes_get",&obj0)) SWIG_fail;
   43685           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   43686           1 :   if (!SWIG_IsOK(res1)) {
   43687           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_numshapes_get" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43688             :   }
   43689           1 :   arg1 = (shapefileObj *)(argp1);
   43690           1 :   result = (int) ((arg1)->numshapes);
   43691             :   resultobj = SWIG_From_int((int)(result));
   43692           1 :   return resultobj;
   43693           0 : fail:
   43694             :   return NULL;
   43695             : }
   43696             : 
   43697             : 
   43698           1 : SWIGINTERN PyObject *_wrap_shapefileObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43699             :   PyObject *resultobj = 0;
   43700             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43701           1 :   void *argp1 = 0 ;
   43702             :   int res1 = 0 ;
   43703           1 :   PyObject * obj0 = 0 ;
   43704             :   rectObj *result = 0 ;
   43705             :   
   43706           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_bounds_get",&obj0)) SWIG_fail;
   43707           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   43708           1 :   if (!SWIG_IsOK(res1)) {
   43709           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_bounds_get" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43710             :   }
   43711           1 :   arg1 = (shapefileObj *)(argp1);
   43712           1 :   result = (rectObj *)& ((arg1)->bounds);
   43713           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 |  0 );
   43714           1 :   return resultobj;
   43715           0 : fail:
   43716             :   return NULL;
   43717             : }
   43718             : 
   43719             : 
   43720           1 : SWIGINTERN PyObject *_wrap_new_shapefileObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43721             :   PyObject *resultobj = 0;
   43722             :   char *arg1 = (char *) 0 ;
   43723             :   int arg2 = (int) -1 ;
   43724             :   int res1 ;
   43725           1 :   char *buf1 = 0 ;
   43726           1 :   int alloc1 = 0 ;
   43727             :   int val2 ;
   43728             :   int ecode2 = 0 ;
   43729           1 :   PyObject * obj0 = 0 ;
   43730           1 :   PyObject * obj1 = 0 ;
   43731             :   shapefileObj *result = 0 ;
   43732             :   
   43733           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:new_shapefileObj",&obj0,&obj1)) SWIG_fail;
   43734           1 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   43735           1 :   if (!SWIG_IsOK(res1)) {
   43736           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_shapefileObj" "', argument " "1"" of type '" "char *""'");
   43737             :   }
   43738           1 :   arg1 = (char *)(buf1);
   43739           1 :   if (obj1) {
   43740             :     ecode2 = SWIG_AsVal_int(obj1, &val2);
   43741           1 :     if (!SWIG_IsOK(ecode2)) {
   43742           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_shapefileObj" "', argument " "2"" of type '" "int""'");
   43743             :     } 
   43744             :     arg2 = (int)(val2);
   43745             :   }
   43746             :   {
   43747           1 :     result = (shapefileObj *)new_shapefileObj(arg1,arg2); {
   43748           1 :       errorObj *ms_error = msGetErrorObj();
   43749             :       
   43750           1 :       switch(ms_error->code) {
   43751             :       case MS_NOERR:
   43752             :         break;
   43753           0 :       case MS_NOTFOUND:
   43754           0 :         msResetErrorList();
   43755           0 :         break;
   43756             :       case -1:
   43757             :         break;
   43758           0 :       case MS_IOERR:
   43759           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43760           0 :           _raise_ms_exception();
   43761           0 :           msResetErrorList();
   43762           0 :           return NULL;
   43763             :         }
   43764             :       default:
   43765           0 :         _raise_ms_exception();
   43766           0 :         msResetErrorList();
   43767           0 :         return NULL;
   43768             :       }
   43769             :       
   43770             :     }
   43771             :   }
   43772           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapefileObj, SWIG_POINTER_NEW |  0 );
   43773           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   43774             :   return resultobj;
   43775           0 : fail:
   43776           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   43777             :   return NULL;
   43778             : }
   43779             : 
   43780             : 
   43781           1 : SWIGINTERN PyObject *_wrap_delete_shapefileObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43782             :   PyObject *resultobj = 0;
   43783             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43784           1 :   void *argp1 = 0 ;
   43785             :   int res1 = 0 ;
   43786           1 :   PyObject * obj0 = 0 ;
   43787             :   
   43788           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_shapefileObj",&obj0)) SWIG_fail;
   43789           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, SWIG_POINTER_DISOWN |  0 );
   43790           1 :   if (!SWIG_IsOK(res1)) {
   43791           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_shapefileObj" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43792             :   }
   43793           1 :   arg1 = (shapefileObj *)(argp1);
   43794             :   {
   43795             :     delete_shapefileObj(arg1); {
   43796           1 :       errorObj *ms_error = msGetErrorObj();
   43797             :       
   43798           1 :       switch(ms_error->code) {
   43799             :       case MS_NOERR:
   43800             :         break;
   43801           0 :       case MS_NOTFOUND:
   43802           0 :         msResetErrorList();
   43803           0 :         break;
   43804             :       case -1:
   43805             :         break;
   43806           0 :       case MS_IOERR:
   43807           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43808           0 :           _raise_ms_exception();
   43809           0 :           msResetErrorList();
   43810           0 :           return NULL;
   43811             :         }
   43812             :       default:
   43813           0 :         _raise_ms_exception();
   43814           0 :         msResetErrorList();
   43815           0 :         return NULL;
   43816             :       }
   43817             :       
   43818             :     }
   43819             :   }
   43820             :   resultobj = SWIG_Py_Void();
   43821           1 :   return resultobj;
   43822           0 : fail:
   43823             :   return NULL;
   43824             : }
   43825             : 
   43826             : 
   43827           1 : SWIGINTERN PyObject *_wrap_shapefileObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43828             :   PyObject *resultobj = 0;
   43829             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43830             :   int arg2 ;
   43831             :   shapeObj *arg3 = (shapeObj *) 0 ;
   43832           1 :   void *argp1 = 0 ;
   43833             :   int res1 = 0 ;
   43834             :   int val2 ;
   43835             :   int ecode2 = 0 ;
   43836           1 :   void *argp3 = 0 ;
   43837             :   int res3 = 0 ;
   43838           1 :   PyObject * obj0 = 0 ;
   43839           1 :   PyObject * obj1 = 0 ;
   43840           1 :   PyObject * obj2 = 0 ;
   43841             :   int result;
   43842             :   
   43843           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:shapefileObj_get",&obj0,&obj1,&obj2)) SWIG_fail;
   43844           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   43845           1 :   if (!SWIG_IsOK(res1)) {
   43846           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_get" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43847             :   }
   43848           1 :   arg1 = (shapefileObj *)(argp1);
   43849           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43850           1 :   if (!SWIG_IsOK(ecode2)) {
   43851           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_get" "', argument " "2"" of type '" "int""'");
   43852             :   } 
   43853             :   arg2 = (int)(val2);
   43854           1 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_shapeObj, 0 |  0 );
   43855           1 :   if (!SWIG_IsOK(res3)) {
   43856           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapefileObj_get" "', argument " "3"" of type '" "shapeObj *""'"); 
   43857             :   }
   43858           1 :   arg3 = (shapeObj *)(argp3);
   43859             :   {
   43860           1 :     result = (int)shapefileObj_get(arg1,arg2,arg3); {
   43861           1 :       errorObj *ms_error = msGetErrorObj();
   43862             :       
   43863           1 :       switch(ms_error->code) {
   43864             :       case MS_NOERR:
   43865             :         break;
   43866           0 :       case MS_NOTFOUND:
   43867           0 :         msResetErrorList();
   43868           0 :         break;
   43869             :       case -1:
   43870             :         break;
   43871           0 :       case MS_IOERR:
   43872           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43873           0 :           _raise_ms_exception();
   43874           0 :           msResetErrorList();
   43875           0 :           return NULL;
   43876             :         }
   43877             :       default:
   43878           0 :         _raise_ms_exception();
   43879           0 :         msResetErrorList();
   43880           0 :         return NULL;
   43881             :       }
   43882             :       
   43883             :     }
   43884             :   }
   43885             :   resultobj = SWIG_From_int((int)(result));
   43886           1 :   return resultobj;
   43887           0 : fail:
   43888             :   return NULL;
   43889             : }
   43890             : 
   43891             : 
   43892           0 : SWIGINTERN PyObject *_wrap_shapefileObj_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43893             :   PyObject *resultobj = 0;
   43894             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43895             :   int arg2 ;
   43896           0 :   void *argp1 = 0 ;
   43897             :   int res1 = 0 ;
   43898             :   int val2 ;
   43899             :   int ecode2 = 0 ;
   43900           0 :   PyObject * obj0 = 0 ;
   43901           0 :   PyObject * obj1 = 0 ;
   43902             :   shapeObj *result = 0 ;
   43903             :   
   43904           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapefileObj_getShape",&obj0,&obj1)) SWIG_fail;
   43905           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   43906           0 :   if (!SWIG_IsOK(res1)) {
   43907           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getShape" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43908             :   }
   43909           0 :   arg1 = (shapefileObj *)(argp1);
   43910           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43911           0 :   if (!SWIG_IsOK(ecode2)) {
   43912           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_getShape" "', argument " "2"" of type '" "int""'");
   43913             :   } 
   43914             :   arg2 = (int)(val2);
   43915             :   {
   43916           0 :     result = (shapeObj *)shapefileObj_getShape(arg1,arg2); {
   43917           0 :       errorObj *ms_error = msGetErrorObj();
   43918             :       
   43919           0 :       switch(ms_error->code) {
   43920             :       case MS_NOERR:
   43921             :         break;
   43922           0 :       case MS_NOTFOUND:
   43923           0 :         msResetErrorList();
   43924           0 :         break;
   43925             :       case -1:
   43926             :         break;
   43927           0 :       case MS_IOERR:
   43928           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43929           0 :           _raise_ms_exception();
   43930           0 :           msResetErrorList();
   43931           0 :           return NULL;
   43932             :         }
   43933             :       default:
   43934           0 :         _raise_ms_exception();
   43935           0 :         msResetErrorList();
   43936           0 :         return NULL;
   43937             :       }
   43938             :       
   43939             :     }
   43940             :   }
   43941           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN |  0 );
   43942           0 :   return resultobj;
   43943           0 : fail:
   43944             :   return NULL;
   43945             : }
   43946             : 
   43947             : 
   43948           0 : SWIGINTERN PyObject *_wrap_shapefileObj_getPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   43949             :   PyObject *resultobj = 0;
   43950             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   43951             :   int arg2 ;
   43952             :   pointObj *arg3 = (pointObj *) 0 ;
   43953           0 :   void *argp1 = 0 ;
   43954             :   int res1 = 0 ;
   43955             :   int val2 ;
   43956             :   int ecode2 = 0 ;
   43957           0 :   void *argp3 = 0 ;
   43958             :   int res3 = 0 ;
   43959           0 :   PyObject * obj0 = 0 ;
   43960           0 :   PyObject * obj1 = 0 ;
   43961           0 :   PyObject * obj2 = 0 ;
   43962             :   int result;
   43963             :   
   43964           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:shapefileObj_getPoint",&obj0,&obj1,&obj2)) SWIG_fail;
   43965           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   43966           0 :   if (!SWIG_IsOK(res1)) {
   43967           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getPoint" "', argument " "1"" of type '" "shapefileObj *""'"); 
   43968             :   }
   43969           0 :   arg1 = (shapefileObj *)(argp1);
   43970           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   43971           0 :   if (!SWIG_IsOK(ecode2)) {
   43972           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_getPoint" "', argument " "2"" of type '" "int""'");
   43973             :   } 
   43974             :   arg2 = (int)(val2);
   43975           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 |  0 );
   43976           0 :   if (!SWIG_IsOK(res3)) {
   43977           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapefileObj_getPoint" "', argument " "3"" of type '" "pointObj *""'"); 
   43978             :   }
   43979           0 :   arg3 = (pointObj *)(argp3);
   43980             :   {
   43981             :     result = (int)shapefileObj_getPoint(arg1,arg2,arg3); {
   43982           0 :       errorObj *ms_error = msGetErrorObj();
   43983             :       
   43984           0 :       switch(ms_error->code) {
   43985             :       case MS_NOERR:
   43986             :         break;
   43987           0 :       case MS_NOTFOUND:
   43988           0 :         msResetErrorList();
   43989           0 :         break;
   43990             :       case -1:
   43991             :         break;
   43992           0 :       case MS_IOERR:
   43993           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   43994           0 :           _raise_ms_exception();
   43995           0 :           msResetErrorList();
   43996           0 :           return NULL;
   43997             :         }
   43998             :       default:
   43999           0 :         _raise_ms_exception();
   44000           0 :         msResetErrorList();
   44001           0 :         return NULL;
   44002             :       }
   44003             :       
   44004             :     }
   44005             :   }
   44006             :   resultobj = SWIG_From_int((int)(result));
   44007           0 :   return resultobj;
   44008           0 : fail:
   44009             :   return NULL;
   44010             : }
   44011             : 
   44012             : 
   44013           0 : SWIGINTERN PyObject *_wrap_shapefileObj_getTransformed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44014             :   PyObject *resultobj = 0;
   44015             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   44016             :   mapObj *arg2 = (mapObj *) 0 ;
   44017             :   int arg3 ;
   44018             :   shapeObj *arg4 = (shapeObj *) 0 ;
   44019           0 :   void *argp1 = 0 ;
   44020             :   int res1 = 0 ;
   44021           0 :   void *argp2 = 0 ;
   44022             :   int res2 = 0 ;
   44023             :   int val3 ;
   44024             :   int ecode3 = 0 ;
   44025           0 :   void *argp4 = 0 ;
   44026             :   int res4 = 0 ;
   44027           0 :   PyObject * obj0 = 0 ;
   44028           0 :   PyObject * obj1 = 0 ;
   44029           0 :   PyObject * obj2 = 0 ;
   44030           0 :   PyObject * obj3 = 0 ;
   44031             :   int result;
   44032             :   
   44033           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOO:shapefileObj_getTransformed",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   44034           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   44035           0 :   if (!SWIG_IsOK(res1)) {
   44036           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getTransformed" "', argument " "1"" of type '" "shapefileObj *""'"); 
   44037             :   }
   44038           0 :   arg1 = (shapefileObj *)(argp1);
   44039           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 |  0 );
   44040           0 :   if (!SWIG_IsOK(res2)) {
   44041           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapefileObj_getTransformed" "', argument " "2"" of type '" "mapObj *""'"); 
   44042             :   }
   44043           0 :   arg2 = (mapObj *)(argp2);
   44044           0 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   44045           0 :   if (!SWIG_IsOK(ecode3)) {
   44046           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "shapefileObj_getTransformed" "', argument " "3"" of type '" "int""'");
   44047             :   } 
   44048             :   arg3 = (int)(val3);
   44049           0 :   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_shapeObj, 0 |  0 );
   44050           0 :   if (!SWIG_IsOK(res4)) {
   44051           0 :     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "shapefileObj_getTransformed" "', argument " "4"" of type '" "shapeObj *""'"); 
   44052             :   }
   44053           0 :   arg4 = (shapeObj *)(argp4);
   44054             :   {
   44055           0 :     result = (int)shapefileObj_getTransformed(arg1,arg2,arg3,arg4); {
   44056           0 :       errorObj *ms_error = msGetErrorObj();
   44057             :       
   44058           0 :       switch(ms_error->code) {
   44059             :       case MS_NOERR:
   44060             :         break;
   44061           0 :       case MS_NOTFOUND:
   44062           0 :         msResetErrorList();
   44063           0 :         break;
   44064             :       case -1:
   44065             :         break;
   44066           0 :       case MS_IOERR:
   44067           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44068           0 :           _raise_ms_exception();
   44069           0 :           msResetErrorList();
   44070           0 :           return NULL;
   44071             :         }
   44072             :       default:
   44073           0 :         _raise_ms_exception();
   44074           0 :         msResetErrorList();
   44075           0 :         return NULL;
   44076             :       }
   44077             :       
   44078             :     }
   44079             :   }
   44080             :   resultobj = SWIG_From_int((int)(result));
   44081           0 :   return resultobj;
   44082           0 : fail:
   44083             :   return NULL;
   44084             : }
   44085             : 
   44086             : 
   44087           0 : SWIGINTERN PyObject *_wrap_shapefileObj_getExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44088             :   PyObject *resultobj = 0;
   44089             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   44090             :   int arg2 ;
   44091             :   rectObj *arg3 = (rectObj *) 0 ;
   44092           0 :   void *argp1 = 0 ;
   44093             :   int res1 = 0 ;
   44094             :   int val2 ;
   44095             :   int ecode2 = 0 ;
   44096           0 :   void *argp3 = 0 ;
   44097             :   int res3 = 0 ;
   44098           0 :   PyObject * obj0 = 0 ;
   44099           0 :   PyObject * obj1 = 0 ;
   44100           0 :   PyObject * obj2 = 0 ;
   44101             :   
   44102           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:shapefileObj_getExtent",&obj0,&obj1,&obj2)) SWIG_fail;
   44103           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   44104           0 :   if (!SWIG_IsOK(res1)) {
   44105           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getExtent" "', argument " "1"" of type '" "shapefileObj *""'"); 
   44106             :   }
   44107           0 :   arg1 = (shapefileObj *)(argp1);
   44108           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44109           0 :   if (!SWIG_IsOK(ecode2)) {
   44110           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_getExtent" "', argument " "2"" of type '" "int""'");
   44111             :   } 
   44112             :   arg2 = (int)(val2);
   44113           0 :   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_rectObj, 0 |  0 );
   44114           0 :   if (!SWIG_IsOK(res3)) {
   44115           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapefileObj_getExtent" "', argument " "3"" of type '" "rectObj *""'"); 
   44116             :   }
   44117           0 :   arg3 = (rectObj *)(argp3);
   44118             :   {
   44119           0 :     shapefileObj_getExtent(arg1,arg2,arg3); {
   44120           0 :       errorObj *ms_error = msGetErrorObj();
   44121             :       
   44122           0 :       switch(ms_error->code) {
   44123             :       case MS_NOERR:
   44124             :         break;
   44125           0 :       case MS_NOTFOUND:
   44126           0 :         msResetErrorList();
   44127           0 :         break;
   44128             :       case -1:
   44129             :         break;
   44130           0 :       case MS_IOERR:
   44131           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44132           0 :           _raise_ms_exception();
   44133           0 :           msResetErrorList();
   44134           0 :           return NULL;
   44135             :         }
   44136             :       default:
   44137           0 :         _raise_ms_exception();
   44138           0 :         msResetErrorList();
   44139           0 :         return NULL;
   44140             :       }
   44141             :       
   44142             :     }
   44143             :   }
   44144             :   resultobj = SWIG_Py_Void();
   44145           0 :   return resultobj;
   44146           0 : fail:
   44147             :   return NULL;
   44148             : }
   44149             : 
   44150             : 
   44151           1 : SWIGINTERN PyObject *_wrap_shapefileObj_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44152             :   PyObject *resultobj = 0;
   44153             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   44154             :   shapeObj *arg2 = (shapeObj *) 0 ;
   44155           1 :   void *argp1 = 0 ;
   44156             :   int res1 = 0 ;
   44157           1 :   void *argp2 = 0 ;
   44158             :   int res2 = 0 ;
   44159           1 :   PyObject * obj0 = 0 ;
   44160           1 :   PyObject * obj1 = 0 ;
   44161             :   int result;
   44162             :   
   44163           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapefileObj_add",&obj0,&obj1)) SWIG_fail;
   44164           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   44165           1 :   if (!SWIG_IsOK(res1)) {
   44166           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_add" "', argument " "1"" of type '" "shapefileObj *""'"); 
   44167             :   }
   44168           1 :   arg1 = (shapefileObj *)(argp1);
   44169           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 |  0 );
   44170           1 :   if (!SWIG_IsOK(res2)) {
   44171           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapefileObj_add" "', argument " "2"" of type '" "shapeObj *""'"); 
   44172             :   }
   44173           1 :   arg2 = (shapeObj *)(argp2);
   44174             :   {
   44175           1 :     result = (int)shapefileObj_add(arg1,arg2); {
   44176           1 :       errorObj *ms_error = msGetErrorObj();
   44177             :       
   44178           1 :       switch(ms_error->code) {
   44179             :       case MS_NOERR:
   44180             :         break;
   44181           0 :       case MS_NOTFOUND:
   44182           0 :         msResetErrorList();
   44183           0 :         break;
   44184             :       case -1:
   44185             :         break;
   44186           0 :       case MS_IOERR:
   44187           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44188           0 :           _raise_ms_exception();
   44189           0 :           msResetErrorList();
   44190           0 :           return NULL;
   44191             :         }
   44192             :       default:
   44193           1 :         _raise_ms_exception();
   44194           1 :         msResetErrorList();
   44195           1 :         return NULL;
   44196             :       }
   44197             :       
   44198             :     }
   44199             :   }
   44200             :   resultobj = SWIG_From_int((int)(result));
   44201           0 :   return resultobj;
   44202           0 : fail:
   44203             :   return NULL;
   44204             : }
   44205             : 
   44206             : 
   44207           0 : SWIGINTERN PyObject *_wrap_shapefileObj_addPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44208             :   PyObject *resultobj = 0;
   44209             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   44210             :   pointObj *arg2 = (pointObj *) 0 ;
   44211           0 :   void *argp1 = 0 ;
   44212             :   int res1 = 0 ;
   44213           0 :   void *argp2 = 0 ;
   44214             :   int res2 = 0 ;
   44215           0 :   PyObject * obj0 = 0 ;
   44216           0 :   PyObject * obj1 = 0 ;
   44217             :   int result;
   44218             :   
   44219           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:shapefileObj_addPoint",&obj0,&obj1)) SWIG_fail;
   44220           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   44221           0 :   if (!SWIG_IsOK(res1)) {
   44222           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_addPoint" "', argument " "1"" of type '" "shapefileObj *""'"); 
   44223             :   }
   44224           0 :   arg1 = (shapefileObj *)(argp1);
   44225           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 |  0 );
   44226           0 :   if (!SWIG_IsOK(res2)) {
   44227           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapefileObj_addPoint" "', argument " "2"" of type '" "pointObj *""'"); 
   44228             :   }
   44229           0 :   arg2 = (pointObj *)(argp2);
   44230             :   {
   44231           0 :     result = (int)shapefileObj_addPoint(arg1,arg2); {
   44232           0 :       errorObj *ms_error = msGetErrorObj();
   44233             :       
   44234           0 :       switch(ms_error->code) {
   44235             :       case MS_NOERR:
   44236             :         break;
   44237           0 :       case MS_NOTFOUND:
   44238           0 :         msResetErrorList();
   44239           0 :         break;
   44240             :       case -1:
   44241             :         break;
   44242           0 :       case MS_IOERR:
   44243           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44244           0 :           _raise_ms_exception();
   44245           0 :           msResetErrorList();
   44246           0 :           return NULL;
   44247             :         }
   44248             :       default:
   44249           0 :         _raise_ms_exception();
   44250           0 :         msResetErrorList();
   44251           0 :         return NULL;
   44252             :       }
   44253             :       
   44254             :     }
   44255             :   }
   44256             :   resultobj = SWIG_From_int((int)(result));
   44257           0 :   return resultobj;
   44258           0 : fail:
   44259             :   return NULL;
   44260             : }
   44261             : 
   44262             : 
   44263           1 : SWIGINTERN PyObject *_wrap_shapefileObj_getDBF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44264             :   PyObject *resultobj = 0;
   44265             :   shapefileObj *arg1 = (shapefileObj *) 0 ;
   44266           1 :   void *argp1 = 0 ;
   44267             :   int res1 = 0 ;
   44268           1 :   PyObject * obj0 = 0 ;
   44269             :   DBFInfo *result = 0 ;
   44270             :   
   44271           1 :   if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_getDBF",&obj0)) SWIG_fail;
   44272           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 |  0 );
   44273           1 :   if (!SWIG_IsOK(res1)) {
   44274           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getDBF" "', argument " "1"" of type '" "shapefileObj *""'"); 
   44275             :   }
   44276           1 :   arg1 = (shapefileObj *)(argp1);
   44277             :   {
   44278           1 :     result = (DBFInfo *)shapefileObj_getDBF(arg1); {
   44279           1 :       errorObj *ms_error = msGetErrorObj();
   44280             :       
   44281           1 :       switch(ms_error->code) {
   44282             :       case MS_NOERR:
   44283             :         break;
   44284           0 :       case MS_NOTFOUND:
   44285           0 :         msResetErrorList();
   44286           0 :         break;
   44287             :       case -1:
   44288             :         break;
   44289           0 :       case MS_IOERR:
   44290           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44291           0 :           _raise_ms_exception();
   44292           0 :           msResetErrorList();
   44293           0 :           return NULL;
   44294             :         }
   44295             :       default:
   44296           0 :         _raise_ms_exception();
   44297           0 :         msResetErrorList();
   44298           0 :         return NULL;
   44299             :       }
   44300             :       
   44301             :     }
   44302             :   }
   44303           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DBFInfo, 0 |  0 );
   44304           1 :   return resultobj;
   44305           0 : fail:
   44306             :   return NULL;
   44307             : }
   44308             : 
   44309             : 
   44310           1 : SWIGINTERN PyObject *shapefileObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44311             :   PyObject *obj;
   44312           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   44313           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_shapefileObj, SWIG_NewClientData(obj));
   44314           1 :   return SWIG_Py_Void();
   44315             : }
   44316             : 
   44317           0 : SWIGINTERN PyObject *_wrap_projectionObj_numargs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44318             :   PyObject *resultobj = 0;
   44319             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44320           0 :   void *argp1 = 0 ;
   44321             :   int res1 = 0 ;
   44322           0 :   PyObject * obj0 = 0 ;
   44323             :   int result;
   44324             :   
   44325           0 :   if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_numargs_get",&obj0)) SWIG_fail;
   44326           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 |  0 );
   44327           0 :   if (!SWIG_IsOK(res1)) {
   44328           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_numargs_get" "', argument " "1"" of type '" "projectionObj *""'"); 
   44329             :   }
   44330           0 :   arg1 = (projectionObj *)(argp1);
   44331           0 :   result = (int) ((arg1)->numargs);
   44332             :   resultobj = SWIG_From_int((int)(result));
   44333           0 :   return resultobj;
   44334           0 : fail:
   44335             :   return NULL;
   44336             : }
   44337             : 
   44338             : 
   44339           0 : SWIGINTERN PyObject *_wrap_projectionObj_automatic_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44340             :   PyObject *resultobj = 0;
   44341             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44342           0 :   void *argp1 = 0 ;
   44343             :   int res1 = 0 ;
   44344           0 :   PyObject * obj0 = 0 ;
   44345             :   int result;
   44346             :   
   44347           0 :   if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_automatic_get",&obj0)) SWIG_fail;
   44348           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 |  0 );
   44349           0 :   if (!SWIG_IsOK(res1)) {
   44350           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_automatic_get" "', argument " "1"" of type '" "projectionObj *""'"); 
   44351             :   }
   44352           0 :   arg1 = (projectionObj *)(argp1);
   44353           0 :   result = (int) ((arg1)->automatic);
   44354             :   resultobj = SWIG_From_int((int)(result));
   44355           0 :   return resultobj;
   44356           0 : fail:
   44357             :   return NULL;
   44358             : }
   44359             : 
   44360             : 
   44361           0 : SWIGINTERN PyObject *_wrap_projectionObj_wellknownprojection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44362             :   PyObject *resultobj = 0;
   44363             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44364             :   int arg2 ;
   44365           0 :   void *argp1 = 0 ;
   44366             :   int res1 = 0 ;
   44367             :   int val2 ;
   44368             :   int ecode2 = 0 ;
   44369           0 :   PyObject * obj0 = 0 ;
   44370           0 :   PyObject * obj1 = 0 ;
   44371             :   
   44372           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:projectionObj_wellknownprojection_set",&obj0,&obj1)) SWIG_fail;
   44373           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 |  0 );
   44374           0 :   if (!SWIG_IsOK(res1)) {
   44375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_wellknownprojection_set" "', argument " "1"" of type '" "projectionObj *""'"); 
   44376             :   }
   44377           0 :   arg1 = (projectionObj *)(argp1);
   44378           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44379           0 :   if (!SWIG_IsOK(ecode2)) {
   44380           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "projectionObj_wellknownprojection_set" "', argument " "2"" of type '" "int""'");
   44381             :   } 
   44382             :   arg2 = (int)(val2);
   44383           0 :   if (arg1) (arg1)->wellknownprojection = arg2;
   44384             :   resultobj = SWIG_Py_Void();
   44385           0 :   return resultobj;
   44386           0 : fail:
   44387             :   return NULL;
   44388             : }
   44389             : 
   44390             : 
   44391           0 : SWIGINTERN PyObject *_wrap_projectionObj_wellknownprojection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44392             :   PyObject *resultobj = 0;
   44393             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44394           0 :   void *argp1 = 0 ;
   44395             :   int res1 = 0 ;
   44396           0 :   PyObject * obj0 = 0 ;
   44397             :   int result;
   44398             :   
   44399           0 :   if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_wellknownprojection_get",&obj0)) SWIG_fail;
   44400           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 |  0 );
   44401           0 :   if (!SWIG_IsOK(res1)) {
   44402           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_wellknownprojection_get" "', argument " "1"" of type '" "projectionObj *""'"); 
   44403             :   }
   44404           0 :   arg1 = (projectionObj *)(argp1);
   44405           0 :   result = (int) ((arg1)->wellknownprojection);
   44406             :   resultobj = SWIG_From_int((int)(result));
   44407           0 :   return resultobj;
   44408           0 : fail:
   44409             :   return NULL;
   44410             : }
   44411             : 
   44412             : 
   44413           1 : SWIGINTERN PyObject *_wrap_new_projectionObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44414             :   PyObject *resultobj = 0;
   44415             :   char *arg1 = (char *) 0 ;
   44416             :   int res1 ;
   44417           1 :   char *buf1 = 0 ;
   44418           1 :   int alloc1 = 0 ;
   44419           1 :   PyObject * obj0 = 0 ;
   44420             :   projectionObj *result = 0 ;
   44421             :   
   44422           1 :   if (!PyArg_ParseTuple(args,(char *)"O:new_projectionObj",&obj0)) SWIG_fail;
   44423           1 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   44424           1 :   if (!SWIG_IsOK(res1)) {
   44425           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_projectionObj" "', argument " "1"" of type '" "char *""'");
   44426             :   }
   44427           1 :   arg1 = (char *)(buf1);
   44428             :   {
   44429           1 :     result = (projectionObj *)new_projectionObj(arg1); {
   44430           1 :       errorObj *ms_error = msGetErrorObj();
   44431             :       
   44432           1 :       switch(ms_error->code) {
   44433             :       case MS_NOERR:
   44434             :         break;
   44435           0 :       case MS_NOTFOUND:
   44436           0 :         msResetErrorList();
   44437           0 :         break;
   44438             :       case -1:
   44439             :         break;
   44440           0 :       case MS_IOERR:
   44441           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44442           0 :           _raise_ms_exception();
   44443           0 :           msResetErrorList();
   44444           0 :           return NULL;
   44445             :         }
   44446             :       default:
   44447           0 :         _raise_ms_exception();
   44448           0 :         msResetErrorList();
   44449           0 :         return NULL;
   44450             :       }
   44451             :       
   44452             :     }
   44453             :   }
   44454           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_projectionObj, SWIG_POINTER_NEW |  0 );
   44455           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   44456             :   return resultobj;
   44457           0 : fail:
   44458           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   44459             :   return NULL;
   44460             : }
   44461             : 
   44462             : 
   44463           1 : SWIGINTERN PyObject *_wrap_delete_projectionObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44464             :   PyObject *resultobj = 0;
   44465             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44466           1 :   void *argp1 = 0 ;
   44467             :   int res1 = 0 ;
   44468           1 :   PyObject * obj0 = 0 ;
   44469             :   
   44470           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_projectionObj",&obj0)) SWIG_fail;
   44471           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, SWIG_POINTER_DISOWN |  0 );
   44472           1 :   if (!SWIG_IsOK(res1)) {
   44473           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_projectionObj" "', argument " "1"" of type '" "projectionObj *""'"); 
   44474             :   }
   44475           1 :   arg1 = (projectionObj *)(argp1);
   44476             :   {
   44477             :     delete_projectionObj(arg1); {
   44478           1 :       errorObj *ms_error = msGetErrorObj();
   44479             :       
   44480           1 :       switch(ms_error->code) {
   44481             :       case MS_NOERR:
   44482             :         break;
   44483           0 :       case MS_NOTFOUND:
   44484           0 :         msResetErrorList();
   44485           0 :         break;
   44486             :       case -1:
   44487             :         break;
   44488           0 :       case MS_IOERR:
   44489           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44490           0 :           _raise_ms_exception();
   44491           0 :           msResetErrorList();
   44492           0 :           return NULL;
   44493             :         }
   44494             :       default:
   44495           0 :         _raise_ms_exception();
   44496           0 :         msResetErrorList();
   44497           0 :         return NULL;
   44498             :       }
   44499             :       
   44500             :     }
   44501             :   }
   44502             :   resultobj = SWIG_Py_Void();
   44503           1 :   return resultobj;
   44504           0 : fail:
   44505             :   return NULL;
   44506             : }
   44507             : 
   44508             : 
   44509           0 : SWIGINTERN PyObject *_wrap_projectionObj_setWKTProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44510             :   PyObject *resultobj = 0;
   44511             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44512             :   char *arg2 = (char *) 0 ;
   44513           0 :   void *argp1 = 0 ;
   44514             :   int res1 = 0 ;
   44515             :   int res2 ;
   44516           0 :   char *buf2 = 0 ;
   44517           0 :   int alloc2 = 0 ;
   44518           0 :   PyObject * obj0 = 0 ;
   44519           0 :   PyObject * obj1 = 0 ;
   44520             :   int result;
   44521             :   
   44522           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:projectionObj_setWKTProjection",&obj0,&obj1)) SWIG_fail;
   44523           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 |  0 );
   44524           0 :   if (!SWIG_IsOK(res1)) {
   44525           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_setWKTProjection" "', argument " "1"" of type '" "projectionObj *""'"); 
   44526             :   }
   44527           0 :   arg1 = (projectionObj *)(argp1);
   44528           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   44529           0 :   if (!SWIG_IsOK(res2)) {
   44530           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "projectionObj_setWKTProjection" "', argument " "2"" of type '" "char *""'");
   44531             :   }
   44532           0 :   arg2 = (char *)(buf2);
   44533             :   {
   44534             :     result = (int)projectionObj_setWKTProjection(arg1,arg2); {
   44535           0 :       errorObj *ms_error = msGetErrorObj();
   44536             :       
   44537           0 :       switch(ms_error->code) {
   44538             :       case MS_NOERR:
   44539             :         break;
   44540           0 :       case MS_NOTFOUND:
   44541           0 :         msResetErrorList();
   44542           0 :         break;
   44543             :       case -1:
   44544             :         break;
   44545           0 :       case MS_IOERR:
   44546           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44547           0 :           _raise_ms_exception();
   44548           0 :           msResetErrorList();
   44549           0 :           return NULL;
   44550             :         }
   44551             :       default:
   44552           0 :         _raise_ms_exception();
   44553           0 :         msResetErrorList();
   44554           0 :         return NULL;
   44555             :       }
   44556             :       
   44557             :     }
   44558             :   }
   44559             :   resultobj = SWIG_From_int((int)(result));
   44560           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   44561             :   return resultobj;
   44562           0 : fail:
   44563           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   44564             :   return NULL;
   44565             : }
   44566             : 
   44567             : 
   44568           1 : SWIGINTERN PyObject *_wrap_projectionObj_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44569             :   PyObject *resultobj = 0;
   44570             :   projectionObj *arg1 = (projectionObj *) 0 ;
   44571           1 :   void *argp1 = 0 ;
   44572             :   int res1 = 0 ;
   44573           1 :   PyObject * obj0 = 0 ;
   44574             :   int result;
   44575             :   
   44576           1 :   if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_getUnits",&obj0)) SWIG_fail;
   44577           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 |  0 );
   44578           1 :   if (!SWIG_IsOK(res1)) {
   44579           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_getUnits" "', argument " "1"" of type '" "projectionObj *""'"); 
   44580             :   }
   44581           1 :   arg1 = (projectionObj *)(argp1);
   44582             :   {
   44583             :     result = (int)projectionObj_getUnits(arg1); {
   44584           1 :       errorObj *ms_error = msGetErrorObj();
   44585             :       
   44586           1 :       switch(ms_error->code) {
   44587             :       case MS_NOERR:
   44588             :         break;
   44589           0 :       case MS_NOTFOUND:
   44590           0 :         msResetErrorList();
   44591           0 :         break;
   44592             :       case -1:
   44593             :         break;
   44594           0 :       case MS_IOERR:
   44595           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44596           0 :           _raise_ms_exception();
   44597           0 :           msResetErrorList();
   44598           0 :           return NULL;
   44599             :         }
   44600             :       default:
   44601           0 :         _raise_ms_exception();
   44602           0 :         msResetErrorList();
   44603           0 :         return NULL;
   44604             :       }
   44605             :       
   44606             :     }
   44607             :   }
   44608             :   resultobj = SWIG_From_int((int)(result));
   44609           1 :   return resultobj;
   44610           0 : fail:
   44611             :   return NULL;
   44612             : }
   44613             : 
   44614             : 
   44615           1 : SWIGINTERN PyObject *projectionObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44616             :   PyObject *obj;
   44617           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   44618           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_projectionObj, SWIG_NewClientData(obj));
   44619           1 :   return SWIG_Py_Void();
   44620             : }
   44621             : 
   44622           0 : SWIGINTERN PyObject *_wrap_colorObj_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44623             :   PyObject *resultobj = 0;
   44624             :   colorObj *arg1 = (colorObj *) 0 ;
   44625             :   int arg2 ;
   44626           0 :   void *argp1 = 0 ;
   44627             :   int res1 = 0 ;
   44628             :   int val2 ;
   44629             :   int ecode2 = 0 ;
   44630           0 :   PyObject * obj0 = 0 ;
   44631           0 :   PyObject * obj1 = 0 ;
   44632             :   
   44633           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_red_set",&obj0,&obj1)) SWIG_fail;
   44634           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44635           0 :   if (!SWIG_IsOK(res1)) {
   44636           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_red_set" "', argument " "1"" of type '" "colorObj *""'"); 
   44637             :   }
   44638           0 :   arg1 = (colorObj *)(argp1);
   44639           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44640           0 :   if (!SWIG_IsOK(ecode2)) {
   44641           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_red_set" "', argument " "2"" of type '" "int""'");
   44642             :   } 
   44643             :   arg2 = (int)(val2);
   44644           0 :   if (arg1) (arg1)->red = arg2;
   44645             :   resultobj = SWIG_Py_Void();
   44646           0 :   return resultobj;
   44647           0 : fail:
   44648             :   return NULL;
   44649             : }
   44650             : 
   44651             : 
   44652           1 : SWIGINTERN PyObject *_wrap_colorObj_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44653             :   PyObject *resultobj = 0;
   44654             :   colorObj *arg1 = (colorObj *) 0 ;
   44655           1 :   void *argp1 = 0 ;
   44656             :   int res1 = 0 ;
   44657           1 :   PyObject * obj0 = 0 ;
   44658             :   int result;
   44659             :   
   44660           1 :   if (!PyArg_ParseTuple(args,(char *)"O:colorObj_red_get",&obj0)) SWIG_fail;
   44661           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44662           1 :   if (!SWIG_IsOK(res1)) {
   44663           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_red_get" "', argument " "1"" of type '" "colorObj *""'"); 
   44664             :   }
   44665           1 :   arg1 = (colorObj *)(argp1);
   44666           1 :   result = (int) ((arg1)->red);
   44667             :   resultobj = SWIG_From_int((int)(result));
   44668           1 :   return resultobj;
   44669           0 : fail:
   44670             :   return NULL;
   44671             : }
   44672             : 
   44673             : 
   44674           0 : SWIGINTERN PyObject *_wrap_colorObj_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44675             :   PyObject *resultobj = 0;
   44676             :   colorObj *arg1 = (colorObj *) 0 ;
   44677             :   int arg2 ;
   44678           0 :   void *argp1 = 0 ;
   44679             :   int res1 = 0 ;
   44680             :   int val2 ;
   44681             :   int ecode2 = 0 ;
   44682           0 :   PyObject * obj0 = 0 ;
   44683           0 :   PyObject * obj1 = 0 ;
   44684             :   
   44685           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_green_set",&obj0,&obj1)) SWIG_fail;
   44686           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44687           0 :   if (!SWIG_IsOK(res1)) {
   44688           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_green_set" "', argument " "1"" of type '" "colorObj *""'"); 
   44689             :   }
   44690           0 :   arg1 = (colorObj *)(argp1);
   44691           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44692           0 :   if (!SWIG_IsOK(ecode2)) {
   44693           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_green_set" "', argument " "2"" of type '" "int""'");
   44694             :   } 
   44695             :   arg2 = (int)(val2);
   44696           0 :   if (arg1) (arg1)->green = arg2;
   44697             :   resultobj = SWIG_Py_Void();
   44698           0 :   return resultobj;
   44699           0 : fail:
   44700             :   return NULL;
   44701             : }
   44702             : 
   44703             : 
   44704           1 : SWIGINTERN PyObject *_wrap_colorObj_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44705             :   PyObject *resultobj = 0;
   44706             :   colorObj *arg1 = (colorObj *) 0 ;
   44707           1 :   void *argp1 = 0 ;
   44708             :   int res1 = 0 ;
   44709           1 :   PyObject * obj0 = 0 ;
   44710             :   int result;
   44711             :   
   44712           1 :   if (!PyArg_ParseTuple(args,(char *)"O:colorObj_green_get",&obj0)) SWIG_fail;
   44713           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44714           1 :   if (!SWIG_IsOK(res1)) {
   44715           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_green_get" "', argument " "1"" of type '" "colorObj *""'"); 
   44716             :   }
   44717           1 :   arg1 = (colorObj *)(argp1);
   44718           1 :   result = (int) ((arg1)->green);
   44719             :   resultobj = SWIG_From_int((int)(result));
   44720           1 :   return resultobj;
   44721           0 : fail:
   44722             :   return NULL;
   44723             : }
   44724             : 
   44725             : 
   44726           0 : SWIGINTERN PyObject *_wrap_colorObj_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44727             :   PyObject *resultobj = 0;
   44728             :   colorObj *arg1 = (colorObj *) 0 ;
   44729             :   int arg2 ;
   44730           0 :   void *argp1 = 0 ;
   44731             :   int res1 = 0 ;
   44732             :   int val2 ;
   44733             :   int ecode2 = 0 ;
   44734           0 :   PyObject * obj0 = 0 ;
   44735           0 :   PyObject * obj1 = 0 ;
   44736             :   
   44737           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_blue_set",&obj0,&obj1)) SWIG_fail;
   44738           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44739           0 :   if (!SWIG_IsOK(res1)) {
   44740           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_blue_set" "', argument " "1"" of type '" "colorObj *""'"); 
   44741             :   }
   44742           0 :   arg1 = (colorObj *)(argp1);
   44743           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44744           0 :   if (!SWIG_IsOK(ecode2)) {
   44745           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_blue_set" "', argument " "2"" of type '" "int""'");
   44746             :   } 
   44747             :   arg2 = (int)(val2);
   44748           0 :   if (arg1) (arg1)->blue = arg2;
   44749             :   resultobj = SWIG_Py_Void();
   44750           0 :   return resultobj;
   44751           0 : fail:
   44752             :   return NULL;
   44753             : }
   44754             : 
   44755             : 
   44756           1 : SWIGINTERN PyObject *_wrap_colorObj_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44757             :   PyObject *resultobj = 0;
   44758             :   colorObj *arg1 = (colorObj *) 0 ;
   44759           1 :   void *argp1 = 0 ;
   44760             :   int res1 = 0 ;
   44761           1 :   PyObject * obj0 = 0 ;
   44762             :   int result;
   44763             :   
   44764           1 :   if (!PyArg_ParseTuple(args,(char *)"O:colorObj_blue_get",&obj0)) SWIG_fail;
   44765           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44766           1 :   if (!SWIG_IsOK(res1)) {
   44767           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_blue_get" "', argument " "1"" of type '" "colorObj *""'"); 
   44768             :   }
   44769           1 :   arg1 = (colorObj *)(argp1);
   44770           1 :   result = (int) ((arg1)->blue);
   44771             :   resultobj = SWIG_From_int((int)(result));
   44772           1 :   return resultobj;
   44773           0 : fail:
   44774             :   return NULL;
   44775             : }
   44776             : 
   44777             : 
   44778           0 : SWIGINTERN PyObject *_wrap_colorObj_alpha_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44779             :   PyObject *resultobj = 0;
   44780             :   colorObj *arg1 = (colorObj *) 0 ;
   44781             :   int arg2 ;
   44782           0 :   void *argp1 = 0 ;
   44783             :   int res1 = 0 ;
   44784             :   int val2 ;
   44785             :   int ecode2 = 0 ;
   44786           0 :   PyObject * obj0 = 0 ;
   44787           0 :   PyObject * obj1 = 0 ;
   44788             :   
   44789           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_alpha_set",&obj0,&obj1)) SWIG_fail;
   44790           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44791           0 :   if (!SWIG_IsOK(res1)) {
   44792           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_alpha_set" "', argument " "1"" of type '" "colorObj *""'"); 
   44793             :   }
   44794           0 :   arg1 = (colorObj *)(argp1);
   44795           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44796           0 :   if (!SWIG_IsOK(ecode2)) {
   44797           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_alpha_set" "', argument " "2"" of type '" "int""'");
   44798             :   } 
   44799             :   arg2 = (int)(val2);
   44800           0 :   if (arg1) (arg1)->alpha = arg2;
   44801             :   resultobj = SWIG_Py_Void();
   44802           0 :   return resultobj;
   44803           0 : fail:
   44804             :   return NULL;
   44805             : }
   44806             : 
   44807             : 
   44808           1 : SWIGINTERN PyObject *_wrap_colorObj_alpha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44809             :   PyObject *resultobj = 0;
   44810             :   colorObj *arg1 = (colorObj *) 0 ;
   44811           1 :   void *argp1 = 0 ;
   44812             :   int res1 = 0 ;
   44813           1 :   PyObject * obj0 = 0 ;
   44814             :   int result;
   44815             :   
   44816           1 :   if (!PyArg_ParseTuple(args,(char *)"O:colorObj_alpha_get",&obj0)) SWIG_fail;
   44817           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44818           1 :   if (!SWIG_IsOK(res1)) {
   44819           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_alpha_get" "', argument " "1"" of type '" "colorObj *""'"); 
   44820             :   }
   44821           1 :   arg1 = (colorObj *)(argp1);
   44822           1 :   result = (int) ((arg1)->alpha);
   44823             :   resultobj = SWIG_From_int((int)(result));
   44824           1 :   return resultobj;
   44825           0 : fail:
   44826             :   return NULL;
   44827             : }
   44828             : 
   44829             : 
   44830           1 : SWIGINTERN PyObject *_wrap_new_colorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44831             :   PyObject *resultobj = 0;
   44832             :   int arg1 = (int) 0 ;
   44833             :   int arg2 = (int) 0 ;
   44834             :   int arg3 = (int) 0 ;
   44835             :   int arg4 = (int) 255 ;
   44836             :   int val1 ;
   44837             :   int ecode1 = 0 ;
   44838             :   int val2 ;
   44839             :   int ecode2 = 0 ;
   44840             :   int val3 ;
   44841             :   int ecode3 = 0 ;
   44842             :   int val4 ;
   44843             :   int ecode4 = 0 ;
   44844           1 :   PyObject * obj0 = 0 ;
   44845           1 :   PyObject * obj1 = 0 ;
   44846           1 :   PyObject * obj2 = 0 ;
   44847           1 :   PyObject * obj3 = 0 ;
   44848             :   colorObj *result = 0 ;
   44849             :   
   44850           1 :   if (!PyArg_ParseTuple(args,(char *)"|OOOO:new_colorObj",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   44851           1 :   if (obj0) {
   44852             :     ecode1 = SWIG_AsVal_int(obj0, &val1);
   44853           1 :     if (!SWIG_IsOK(ecode1)) {
   44854           0 :       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_colorObj" "', argument " "1"" of type '" "int""'");
   44855             :     } 
   44856             :     arg1 = (int)(val1);
   44857             :   }
   44858           1 :   if (obj1) {
   44859             :     ecode2 = SWIG_AsVal_int(obj1, &val2);
   44860           1 :     if (!SWIG_IsOK(ecode2)) {
   44861           0 :       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_colorObj" "', argument " "2"" of type '" "int""'");
   44862             :     } 
   44863             :     arg2 = (int)(val2);
   44864             :   }
   44865           1 :   if (obj2) {
   44866             :     ecode3 = SWIG_AsVal_int(obj2, &val3);
   44867           1 :     if (!SWIG_IsOK(ecode3)) {
   44868           0 :       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_colorObj" "', argument " "3"" of type '" "int""'");
   44869             :     } 
   44870             :     arg3 = (int)(val3);
   44871             :   }
   44872           1 :   if (obj3) {
   44873             :     ecode4 = SWIG_AsVal_int(obj3, &val4);
   44874           1 :     if (!SWIG_IsOK(ecode4)) {
   44875           0 :       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_colorObj" "', argument " "4"" of type '" "int""'");
   44876             :     } 
   44877             :     arg4 = (int)(val4);
   44878             :   }
   44879             :   {
   44880           1 :     result = (colorObj *)new_colorObj(arg1,arg2,arg3,arg4); {
   44881           1 :       errorObj *ms_error = msGetErrorObj();
   44882             :       
   44883           1 :       switch(ms_error->code) {
   44884             :       case MS_NOERR:
   44885             :         break;
   44886           0 :       case MS_NOTFOUND:
   44887           0 :         msResetErrorList();
   44888           0 :         break;
   44889             :       case -1:
   44890             :         break;
   44891           0 :       case MS_IOERR:
   44892           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44893           0 :           _raise_ms_exception();
   44894           0 :           msResetErrorList();
   44895           0 :           return NULL;
   44896             :         }
   44897             :       default:
   44898           0 :         _raise_ms_exception();
   44899           0 :         msResetErrorList();
   44900           0 :         return NULL;
   44901             :       }
   44902             :       
   44903             :     }
   44904             :   }
   44905           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, SWIG_POINTER_NEW |  0 );
   44906           1 :   return resultobj;
   44907           0 : fail:
   44908             :   return NULL;
   44909             : }
   44910             : 
   44911             : 
   44912           1 : SWIGINTERN PyObject *_wrap_delete_colorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44913             :   PyObject *resultobj = 0;
   44914             :   colorObj *arg1 = (colorObj *) 0 ;
   44915           1 :   void *argp1 = 0 ;
   44916             :   int res1 = 0 ;
   44917           1 :   PyObject * obj0 = 0 ;
   44918             :   
   44919           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_colorObj",&obj0)) SWIG_fail;
   44920           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, SWIG_POINTER_DISOWN |  0 );
   44921           1 :   if (!SWIG_IsOK(res1)) {
   44922           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_colorObj" "', argument " "1"" of type '" "colorObj *""'"); 
   44923             :   }
   44924           1 :   arg1 = (colorObj *)(argp1);
   44925             :   {
   44926             :     delete_colorObj(arg1); {
   44927           1 :       errorObj *ms_error = msGetErrorObj();
   44928             :       
   44929           1 :       switch(ms_error->code) {
   44930             :       case MS_NOERR:
   44931             :         break;
   44932           0 :       case MS_NOTFOUND:
   44933           0 :         msResetErrorList();
   44934           0 :         break;
   44935             :       case -1:
   44936             :         break;
   44937           0 :       case MS_IOERR:
   44938           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   44939           0 :           _raise_ms_exception();
   44940           0 :           msResetErrorList();
   44941           0 :           return NULL;
   44942             :         }
   44943             :       default:
   44944           0 :         _raise_ms_exception();
   44945           0 :         msResetErrorList();
   44946           0 :         return NULL;
   44947             :       }
   44948             :       
   44949             :     }
   44950             :   }
   44951             :   resultobj = SWIG_Py_Void();
   44952           1 :   return resultobj;
   44953           0 : fail:
   44954             :   return NULL;
   44955             : }
   44956             : 
   44957             : 
   44958           1 : SWIGINTERN PyObject *_wrap_colorObj_setRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   44959             :   PyObject *resultobj = 0;
   44960             :   colorObj *arg1 = (colorObj *) 0 ;
   44961             :   int arg2 ;
   44962             :   int arg3 ;
   44963             :   int arg4 ;
   44964             :   int arg5 = (int) 255 ;
   44965           1 :   void *argp1 = 0 ;
   44966             :   int res1 = 0 ;
   44967             :   int val2 ;
   44968             :   int ecode2 = 0 ;
   44969             :   int val3 ;
   44970             :   int ecode3 = 0 ;
   44971             :   int val4 ;
   44972             :   int ecode4 = 0 ;
   44973             :   int val5 ;
   44974             :   int ecode5 = 0 ;
   44975           1 :   PyObject * obj0 = 0 ;
   44976           1 :   PyObject * obj1 = 0 ;
   44977           1 :   PyObject * obj2 = 0 ;
   44978           1 :   PyObject * obj3 = 0 ;
   44979           1 :   PyObject * obj4 = 0 ;
   44980             :   int result;
   44981             :   
   44982           1 :   if (!PyArg_ParseTuple(args,(char *)"OOOO|O:colorObj_setRGB",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   44983           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   44984           1 :   if (!SWIG_IsOK(res1)) {
   44985           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_setRGB" "', argument " "1"" of type '" "colorObj *""'"); 
   44986             :   }
   44987           1 :   arg1 = (colorObj *)(argp1);
   44988           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   44989           1 :   if (!SWIG_IsOK(ecode2)) {
   44990           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_setRGB" "', argument " "2"" of type '" "int""'");
   44991             :   } 
   44992             :   arg2 = (int)(val2);
   44993           1 :   ecode3 = SWIG_AsVal_int(obj2, &val3);
   44994           1 :   if (!SWIG_IsOK(ecode3)) {
   44995           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "colorObj_setRGB" "', argument " "3"" of type '" "int""'");
   44996             :   } 
   44997             :   arg3 = (int)(val3);
   44998           1 :   ecode4 = SWIG_AsVal_int(obj3, &val4);
   44999           1 :   if (!SWIG_IsOK(ecode4)) {
   45000           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "colorObj_setRGB" "', argument " "4"" of type '" "int""'");
   45001             :   } 
   45002             :   arg4 = (int)(val4);
   45003           1 :   if (obj4) {
   45004             :     ecode5 = SWIG_AsVal_int(obj4, &val5);
   45005           1 :     if (!SWIG_IsOK(ecode5)) {
   45006           0 :       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "colorObj_setRGB" "', argument " "5"" of type '" "int""'");
   45007             :     } 
   45008             :     arg5 = (int)(val5);
   45009             :   }
   45010             :   {
   45011           1 :     result = (int)colorObj_setRGB(arg1,arg2,arg3,arg4,arg5); {
   45012           1 :       errorObj *ms_error = msGetErrorObj();
   45013             :       
   45014           1 :       switch(ms_error->code) {
   45015             :       case MS_NOERR:
   45016             :         break;
   45017           0 :       case MS_NOTFOUND:
   45018           0 :         msResetErrorList();
   45019           0 :         break;
   45020             :       case -1:
   45021             :         break;
   45022           0 :       case MS_IOERR:
   45023           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   45024           0 :           _raise_ms_exception();
   45025           0 :           msResetErrorList();
   45026           0 :           return NULL;
   45027             :         }
   45028             :       default:
   45029           0 :         _raise_ms_exception();
   45030           0 :         msResetErrorList();
   45031           0 :         return NULL;
   45032             :       }
   45033             :       
   45034             :     }
   45035             :   }
   45036             :   resultobj = SWIG_From_int((int)(result));
   45037           1 :   return resultobj;
   45038           0 : fail:
   45039             :   return NULL;
   45040             : }
   45041             : 
   45042             : 
   45043           1 : SWIGINTERN PyObject *_wrap_colorObj_setHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45044             :   PyObject *resultobj = 0;
   45045             :   colorObj *arg1 = (colorObj *) 0 ;
   45046             :   char *arg2 = (char *) 0 ;
   45047           1 :   void *argp1 = 0 ;
   45048             :   int res1 = 0 ;
   45049             :   int res2 ;
   45050           1 :   char *buf2 = 0 ;
   45051           1 :   int alloc2 = 0 ;
   45052           1 :   PyObject * obj0 = 0 ;
   45053           1 :   PyObject * obj1 = 0 ;
   45054             :   int result;
   45055             :   
   45056           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_setHex",&obj0,&obj1)) SWIG_fail;
   45057           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   45058           1 :   if (!SWIG_IsOK(res1)) {
   45059           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_setHex" "', argument " "1"" of type '" "colorObj *""'"); 
   45060             :   }
   45061           1 :   arg1 = (colorObj *)(argp1);
   45062           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   45063           1 :   if (!SWIG_IsOK(res2)) {
   45064           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "colorObj_setHex" "', argument " "2"" of type '" "char *""'");
   45065             :   }
   45066           1 :   arg2 = (char *)(buf2);
   45067             :   {
   45068           1 :     result = (int)colorObj_setHex(arg1,arg2); {
   45069           1 :       errorObj *ms_error = msGetErrorObj();
   45070             :       
   45071           1 :       switch(ms_error->code) {
   45072             :       case MS_NOERR:
   45073             :         break;
   45074           0 :       case MS_NOTFOUND:
   45075           0 :         msResetErrorList();
   45076           0 :         break;
   45077             :       case -1:
   45078             :         break;
   45079           0 :       case MS_IOERR:
   45080           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   45081           0 :           _raise_ms_exception();
   45082           0 :           msResetErrorList();
   45083           0 :           return NULL;
   45084             :         }
   45085             :       default:
   45086           1 :         _raise_ms_exception();
   45087           1 :         msResetErrorList();
   45088           1 :         return NULL;
   45089             :       }
   45090             :       
   45091             :     }
   45092             :   }
   45093             :   resultobj = SWIG_From_int((int)(result));
   45094           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   45095             :   return resultobj;
   45096           0 : fail:
   45097           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   45098             :   return NULL;
   45099             : }
   45100             : 
   45101             : 
   45102           1 : SWIGINTERN PyObject *_wrap_colorObj_toHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45103             :   PyObject *resultobj = 0;
   45104             :   colorObj *arg1 = (colorObj *) 0 ;
   45105           1 :   void *argp1 = 0 ;
   45106             :   int res1 = 0 ;
   45107           1 :   PyObject * obj0 = 0 ;
   45108             :   char *result = 0 ;
   45109             :   
   45110           1 :   if (!PyArg_ParseTuple(args,(char *)"O:colorObj_toHex",&obj0)) SWIG_fail;
   45111           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 |  0 );
   45112           1 :   if (!SWIG_IsOK(res1)) {
   45113           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_toHex" "', argument " "1"" of type '" "colorObj *""'"); 
   45114             :   }
   45115           1 :   arg1 = (colorObj *)(argp1);
   45116             :   {
   45117           1 :     result = (char *)colorObj_toHex(arg1); {
   45118           1 :       errorObj *ms_error = msGetErrorObj();
   45119             :       
   45120           1 :       switch(ms_error->code) {
   45121             :       case MS_NOERR:
   45122             :         break;
   45123           0 :       case MS_NOTFOUND:
   45124           0 :         msResetErrorList();
   45125           0 :         break;
   45126             :       case -1:
   45127             :         break;
   45128           0 :       case MS_IOERR:
   45129           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   45130           0 :           _raise_ms_exception();
   45131           0 :           msResetErrorList();
   45132           0 :           return NULL;
   45133             :         }
   45134             :       default:
   45135           1 :         _raise_ms_exception();
   45136           1 :         msResetErrorList();
   45137           1 :         return NULL;
   45138             :       }
   45139             :       
   45140             :     }
   45141             :   }
   45142           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   45143           1 :   free((char*)result);
   45144           1 :   return resultobj;
   45145           0 : fail:
   45146             :   return NULL;
   45147             : }
   45148             : 
   45149             : 
   45150           1 : SWIGINTERN PyObject *colorObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45151             :   PyObject *obj;
   45152           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   45153           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_colorObj, SWIG_NewClientData(obj));
   45154           1 :   return SWIG_Py_Void();
   45155             : }
   45156             : 
   45157           0 : SWIGINTERN PyObject *_wrap_symbolObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45158             :   PyObject *resultobj = 0;
   45159             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45160             :   char *arg2 = (char *) 0 ;
   45161           0 :   void *argp1 = 0 ;
   45162             :   int res1 = 0 ;
   45163             :   int res2 ;
   45164           0 :   char *buf2 = 0 ;
   45165           0 :   int alloc2 = 0 ;
   45166           0 :   PyObject * obj0 = 0 ;
   45167           0 :   PyObject * obj1 = 0 ;
   45168             :   
   45169           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_name_set",&obj0,&obj1)) SWIG_fail;
   45170           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45171           0 :   if (!SWIG_IsOK(res1)) {
   45172           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_name_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45173             :   }
   45174           0 :   arg1 = (struct symbolObj *)(argp1);
   45175           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   45176           0 :   if (!SWIG_IsOK(res2)) {
   45177           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_name_set" "', argument " "2"" of type '" "char *""'");
   45178             :   }
   45179           0 :   arg2 = (char *)(buf2);
   45180             :   {
   45181           0 :     if (arg1->name) free((char*)arg1->name);
   45182           0 :     if (arg2) {
   45183           0 :       arg1->name = (char *) malloc(strlen(arg2)+1);
   45184             :       strcpy((char*)arg1->name,arg2);
   45185             :     } else {
   45186           0 :       arg1->name = 0;
   45187             :     }
   45188             :   }
   45189             :   resultobj = SWIG_Py_Void();
   45190           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   45191             :   return resultobj;
   45192           0 : fail:
   45193           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   45194             :   return NULL;
   45195             : }
   45196             : 
   45197             : 
   45198           1 : SWIGINTERN PyObject *_wrap_symbolObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45199             :   PyObject *resultobj = 0;
   45200             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45201           1 :   void *argp1 = 0 ;
   45202             :   int res1 = 0 ;
   45203           1 :   PyObject * obj0 = 0 ;
   45204             :   char *result = 0 ;
   45205             :   
   45206           1 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_name_get",&obj0)) SWIG_fail;
   45207           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45208           1 :   if (!SWIG_IsOK(res1)) {
   45209           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_name_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45210             :   }
   45211           1 :   arg1 = (struct symbolObj *)(argp1);
   45212           1 :   result = (char *) ((arg1)->name);
   45213           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   45214           1 :   return resultobj;
   45215           0 : fail:
   45216             :   return NULL;
   45217             : }
   45218             : 
   45219             : 
   45220           0 : SWIGINTERN PyObject *_wrap_symbolObj_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45221             :   PyObject *resultobj = 0;
   45222             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45223             :   int arg2 ;
   45224           0 :   void *argp1 = 0 ;
   45225             :   int res1 = 0 ;
   45226             :   int val2 ;
   45227             :   int ecode2 = 0 ;
   45228           0 :   PyObject * obj0 = 0 ;
   45229           0 :   PyObject * obj1 = 0 ;
   45230             :   
   45231           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_type_set",&obj0,&obj1)) SWIG_fail;
   45232           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45233           0 :   if (!SWIG_IsOK(res1)) {
   45234           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_type_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45235             :   }
   45236           0 :   arg1 = (struct symbolObj *)(argp1);
   45237           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   45238           0 :   if (!SWIG_IsOK(ecode2)) {
   45239           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_type_set" "', argument " "2"" of type '" "int""'");
   45240             :   } 
   45241             :   arg2 = (int)(val2);
   45242           0 :   if (arg1) (arg1)->type = arg2;
   45243             :   resultobj = SWIG_Py_Void();
   45244           0 :   return resultobj;
   45245           0 : fail:
   45246             :   return NULL;
   45247             : }
   45248             : 
   45249             : 
   45250           1 : SWIGINTERN PyObject *_wrap_symbolObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45251             :   PyObject *resultobj = 0;
   45252             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45253           1 :   void *argp1 = 0 ;
   45254             :   int res1 = 0 ;
   45255           1 :   PyObject * obj0 = 0 ;
   45256             :   int result;
   45257             :   
   45258           1 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_type_get",&obj0)) SWIG_fail;
   45259           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45260           1 :   if (!SWIG_IsOK(res1)) {
   45261           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_type_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45262             :   }
   45263           1 :   arg1 = (struct symbolObj *)(argp1);
   45264           1 :   result = (int) ((arg1)->type);
   45265             :   resultobj = SWIG_From_int((int)(result));
   45266           1 :   return resultobj;
   45267           0 : fail:
   45268             :   return NULL;
   45269             : }
   45270             : 
   45271             : 
   45272           0 : SWIGINTERN PyObject *_wrap_symbolObj_inmapfile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45273             :   PyObject *resultobj = 0;
   45274             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45275             :   int arg2 ;
   45276           0 :   void *argp1 = 0 ;
   45277             :   int res1 = 0 ;
   45278             :   int val2 ;
   45279             :   int ecode2 = 0 ;
   45280           0 :   PyObject * obj0 = 0 ;
   45281           0 :   PyObject * obj1 = 0 ;
   45282             :   
   45283           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_inmapfile_set",&obj0,&obj1)) SWIG_fail;
   45284           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45285           0 :   if (!SWIG_IsOK(res1)) {
   45286           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_inmapfile_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45287             :   }
   45288           0 :   arg1 = (struct symbolObj *)(argp1);
   45289           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   45290           0 :   if (!SWIG_IsOK(ecode2)) {
   45291           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_inmapfile_set" "', argument " "2"" of type '" "int""'");
   45292             :   } 
   45293             :   arg2 = (int)(val2);
   45294           0 :   if (arg1) (arg1)->inmapfile = arg2;
   45295             :   resultobj = SWIG_Py_Void();
   45296           0 :   return resultobj;
   45297           0 : fail:
   45298             :   return NULL;
   45299             : }
   45300             : 
   45301             : 
   45302           0 : SWIGINTERN PyObject *_wrap_symbolObj_inmapfile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45303             :   PyObject *resultobj = 0;
   45304             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45305           0 :   void *argp1 = 0 ;
   45306             :   int res1 = 0 ;
   45307           0 :   PyObject * obj0 = 0 ;
   45308             :   int result;
   45309             :   
   45310           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_inmapfile_get",&obj0)) SWIG_fail;
   45311           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45312           0 :   if (!SWIG_IsOK(res1)) {
   45313           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_inmapfile_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45314             :   }
   45315           0 :   arg1 = (struct symbolObj *)(argp1);
   45316           0 :   result = (int) ((arg1)->inmapfile);
   45317             :   resultobj = SWIG_From_int((int)(result));
   45318           0 :   return resultobj;
   45319           0 : fail:
   45320             :   return NULL;
   45321             : }
   45322             : 
   45323             : 
   45324           0 : SWIGINTERN PyObject *_wrap_symbolObj_sizex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45325             :   PyObject *resultobj = 0;
   45326             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45327             :   double arg2 ;
   45328           0 :   void *argp1 = 0 ;
   45329             :   int res1 = 0 ;
   45330             :   double val2 ;
   45331             :   int ecode2 = 0 ;
   45332           0 :   PyObject * obj0 = 0 ;
   45333           0 :   PyObject * obj1 = 0 ;
   45334             :   
   45335           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_sizex_set",&obj0,&obj1)) SWIG_fail;
   45336           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45337           0 :   if (!SWIG_IsOK(res1)) {
   45338           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizex_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45339             :   }
   45340           0 :   arg1 = (struct symbolObj *)(argp1);
   45341           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45342           0 :   if (!SWIG_IsOK(ecode2)) {
   45343           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_sizex_set" "', argument " "2"" of type '" "double""'");
   45344             :   } 
   45345           0 :   arg2 = (double)(val2);
   45346           0 :   if (arg1) (arg1)->sizex = arg2;
   45347             :   resultobj = SWIG_Py_Void();
   45348           0 :   return resultobj;
   45349           0 : fail:
   45350             :   return NULL;
   45351             : }
   45352             : 
   45353             : 
   45354           0 : SWIGINTERN PyObject *_wrap_symbolObj_sizex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45355             :   PyObject *resultobj = 0;
   45356             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45357           0 :   void *argp1 = 0 ;
   45358             :   int res1 = 0 ;
   45359           0 :   PyObject * obj0 = 0 ;
   45360             :   double result;
   45361             :   
   45362           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_sizex_get",&obj0)) SWIG_fail;
   45363           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45364           0 :   if (!SWIG_IsOK(res1)) {
   45365           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizex_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45366             :   }
   45367           0 :   arg1 = (struct symbolObj *)(argp1);
   45368           0 :   result = (double) ((arg1)->sizex);
   45369           0 :   resultobj = SWIG_From_double((double)(result));
   45370           0 :   return resultobj;
   45371           0 : fail:
   45372             :   return NULL;
   45373             : }
   45374             : 
   45375             : 
   45376           0 : SWIGINTERN PyObject *_wrap_symbolObj_sizey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45377             :   PyObject *resultobj = 0;
   45378             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45379             :   double arg2 ;
   45380           0 :   void *argp1 = 0 ;
   45381             :   int res1 = 0 ;
   45382             :   double val2 ;
   45383             :   int ecode2 = 0 ;
   45384           0 :   PyObject * obj0 = 0 ;
   45385           0 :   PyObject * obj1 = 0 ;
   45386             :   
   45387           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_sizey_set",&obj0,&obj1)) SWIG_fail;
   45388           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45389           0 :   if (!SWIG_IsOK(res1)) {
   45390           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizey_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45391             :   }
   45392           0 :   arg1 = (struct symbolObj *)(argp1);
   45393           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45394           0 :   if (!SWIG_IsOK(ecode2)) {
   45395           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_sizey_set" "', argument " "2"" of type '" "double""'");
   45396             :   } 
   45397           0 :   arg2 = (double)(val2);
   45398           0 :   if (arg1) (arg1)->sizey = arg2;
   45399             :   resultobj = SWIG_Py_Void();
   45400           0 :   return resultobj;
   45401           0 : fail:
   45402             :   return NULL;
   45403             : }
   45404             : 
   45405             : 
   45406           0 : SWIGINTERN PyObject *_wrap_symbolObj_sizey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45407             :   PyObject *resultobj = 0;
   45408             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45409           0 :   void *argp1 = 0 ;
   45410             :   int res1 = 0 ;
   45411           0 :   PyObject * obj0 = 0 ;
   45412             :   double result;
   45413             :   
   45414           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_sizey_get",&obj0)) SWIG_fail;
   45415           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45416           0 :   if (!SWIG_IsOK(res1)) {
   45417           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizey_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45418             :   }
   45419           0 :   arg1 = (struct symbolObj *)(argp1);
   45420           0 :   result = (double) ((arg1)->sizey);
   45421           0 :   resultobj = SWIG_From_double((double)(result));
   45422           0 :   return resultobj;
   45423           0 : fail:
   45424             :   return NULL;
   45425             : }
   45426             : 
   45427             : 
   45428           0 : SWIGINTERN PyObject *_wrap_symbolObj_minx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45429             :   PyObject *resultobj = 0;
   45430             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45431             :   double arg2 ;
   45432           0 :   void *argp1 = 0 ;
   45433             :   int res1 = 0 ;
   45434             :   double val2 ;
   45435             :   int ecode2 = 0 ;
   45436           0 :   PyObject * obj0 = 0 ;
   45437           0 :   PyObject * obj1 = 0 ;
   45438             :   
   45439           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_minx_set",&obj0,&obj1)) SWIG_fail;
   45440           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45441           0 :   if (!SWIG_IsOK(res1)) {
   45442           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_minx_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45443             :   }
   45444           0 :   arg1 = (struct symbolObj *)(argp1);
   45445           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45446           0 :   if (!SWIG_IsOK(ecode2)) {
   45447           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_minx_set" "', argument " "2"" of type '" "double""'");
   45448             :   } 
   45449           0 :   arg2 = (double)(val2);
   45450           0 :   if (arg1) (arg1)->minx = arg2;
   45451             :   resultobj = SWIG_Py_Void();
   45452           0 :   return resultobj;
   45453           0 : fail:
   45454             :   return NULL;
   45455             : }
   45456             : 
   45457             : 
   45458           0 : SWIGINTERN PyObject *_wrap_symbolObj_minx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45459             :   PyObject *resultobj = 0;
   45460             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45461           0 :   void *argp1 = 0 ;
   45462             :   int res1 = 0 ;
   45463           0 :   PyObject * obj0 = 0 ;
   45464             :   double result;
   45465             :   
   45466           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_minx_get",&obj0)) SWIG_fail;
   45467           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45468           0 :   if (!SWIG_IsOK(res1)) {
   45469           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_minx_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45470             :   }
   45471           0 :   arg1 = (struct symbolObj *)(argp1);
   45472           0 :   result = (double) ((arg1)->minx);
   45473           0 :   resultobj = SWIG_From_double((double)(result));
   45474           0 :   return resultobj;
   45475           0 : fail:
   45476             :   return NULL;
   45477             : }
   45478             : 
   45479             : 
   45480           0 : SWIGINTERN PyObject *_wrap_symbolObj_miny_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45481             :   PyObject *resultobj = 0;
   45482             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45483             :   double arg2 ;
   45484           0 :   void *argp1 = 0 ;
   45485             :   int res1 = 0 ;
   45486             :   double val2 ;
   45487             :   int ecode2 = 0 ;
   45488           0 :   PyObject * obj0 = 0 ;
   45489           0 :   PyObject * obj1 = 0 ;
   45490             :   
   45491           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_miny_set",&obj0,&obj1)) SWIG_fail;
   45492           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45493           0 :   if (!SWIG_IsOK(res1)) {
   45494           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_miny_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45495             :   }
   45496           0 :   arg1 = (struct symbolObj *)(argp1);
   45497           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45498           0 :   if (!SWIG_IsOK(ecode2)) {
   45499           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_miny_set" "', argument " "2"" of type '" "double""'");
   45500             :   } 
   45501           0 :   arg2 = (double)(val2);
   45502           0 :   if (arg1) (arg1)->miny = arg2;
   45503             :   resultobj = SWIG_Py_Void();
   45504           0 :   return resultobj;
   45505           0 : fail:
   45506             :   return NULL;
   45507             : }
   45508             : 
   45509             : 
   45510           0 : SWIGINTERN PyObject *_wrap_symbolObj_miny_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45511             :   PyObject *resultobj = 0;
   45512             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45513           0 :   void *argp1 = 0 ;
   45514             :   int res1 = 0 ;
   45515           0 :   PyObject * obj0 = 0 ;
   45516             :   double result;
   45517             :   
   45518           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_miny_get",&obj0)) SWIG_fail;
   45519           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45520           0 :   if (!SWIG_IsOK(res1)) {
   45521           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_miny_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45522             :   }
   45523           0 :   arg1 = (struct symbolObj *)(argp1);
   45524           0 :   result = (double) ((arg1)->miny);
   45525           0 :   resultobj = SWIG_From_double((double)(result));
   45526           0 :   return resultobj;
   45527           0 : fail:
   45528             :   return NULL;
   45529             : }
   45530             : 
   45531             : 
   45532           0 : SWIGINTERN PyObject *_wrap_symbolObj_maxx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45533             :   PyObject *resultobj = 0;
   45534             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45535             :   double arg2 ;
   45536           0 :   void *argp1 = 0 ;
   45537             :   int res1 = 0 ;
   45538             :   double val2 ;
   45539             :   int ecode2 = 0 ;
   45540           0 :   PyObject * obj0 = 0 ;
   45541           0 :   PyObject * obj1 = 0 ;
   45542             :   
   45543           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_maxx_set",&obj0,&obj1)) SWIG_fail;
   45544           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45545           0 :   if (!SWIG_IsOK(res1)) {
   45546           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxx_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45547             :   }
   45548           0 :   arg1 = (struct symbolObj *)(argp1);
   45549           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45550           0 :   if (!SWIG_IsOK(ecode2)) {
   45551           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_maxx_set" "', argument " "2"" of type '" "double""'");
   45552             :   } 
   45553           0 :   arg2 = (double)(val2);
   45554           0 :   if (arg1) (arg1)->maxx = arg2;
   45555             :   resultobj = SWIG_Py_Void();
   45556           0 :   return resultobj;
   45557           0 : fail:
   45558             :   return NULL;
   45559             : }
   45560             : 
   45561             : 
   45562           0 : SWIGINTERN PyObject *_wrap_symbolObj_maxx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45563             :   PyObject *resultobj = 0;
   45564             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45565           0 :   void *argp1 = 0 ;
   45566             :   int res1 = 0 ;
   45567           0 :   PyObject * obj0 = 0 ;
   45568             :   double result;
   45569             :   
   45570           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_maxx_get",&obj0)) SWIG_fail;
   45571           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45572           0 :   if (!SWIG_IsOK(res1)) {
   45573           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxx_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45574             :   }
   45575           0 :   arg1 = (struct symbolObj *)(argp1);
   45576           0 :   result = (double) ((arg1)->maxx);
   45577           0 :   resultobj = SWIG_From_double((double)(result));
   45578           0 :   return resultobj;
   45579           0 : fail:
   45580             :   return NULL;
   45581             : }
   45582             : 
   45583             : 
   45584           0 : SWIGINTERN PyObject *_wrap_symbolObj_maxy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45585             :   PyObject *resultobj = 0;
   45586             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45587             :   double arg2 ;
   45588           0 :   void *argp1 = 0 ;
   45589             :   int res1 = 0 ;
   45590             :   double val2 ;
   45591             :   int ecode2 = 0 ;
   45592           0 :   PyObject * obj0 = 0 ;
   45593           0 :   PyObject * obj1 = 0 ;
   45594             :   
   45595           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_maxy_set",&obj0,&obj1)) SWIG_fail;
   45596           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45597           0 :   if (!SWIG_IsOK(res1)) {
   45598           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxy_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45599             :   }
   45600           0 :   arg1 = (struct symbolObj *)(argp1);
   45601           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45602           0 :   if (!SWIG_IsOK(ecode2)) {
   45603           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_maxy_set" "', argument " "2"" of type '" "double""'");
   45604             :   } 
   45605           0 :   arg2 = (double)(val2);
   45606           0 :   if (arg1) (arg1)->maxy = arg2;
   45607             :   resultobj = SWIG_Py_Void();
   45608           0 :   return resultobj;
   45609           0 : fail:
   45610             :   return NULL;
   45611             : }
   45612             : 
   45613             : 
   45614           0 : SWIGINTERN PyObject *_wrap_symbolObj_maxy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45615             :   PyObject *resultobj = 0;
   45616             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45617           0 :   void *argp1 = 0 ;
   45618             :   int res1 = 0 ;
   45619           0 :   PyObject * obj0 = 0 ;
   45620             :   double result;
   45621             :   
   45622           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_maxy_get",&obj0)) SWIG_fail;
   45623           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45624           0 :   if (!SWIG_IsOK(res1)) {
   45625           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxy_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45626             :   }
   45627           0 :   arg1 = (struct symbolObj *)(argp1);
   45628           0 :   result = (double) ((arg1)->maxy);
   45629           0 :   resultobj = SWIG_From_double((double)(result));
   45630           0 :   return resultobj;
   45631           0 : fail:
   45632             :   return NULL;
   45633             : }
   45634             : 
   45635             : 
   45636           1 : SWIGINTERN PyObject *_wrap_symbolObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45637             :   PyObject *resultobj = 0;
   45638             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45639           1 :   void *argp1 = 0 ;
   45640             :   int res1 = 0 ;
   45641           1 :   PyObject * obj0 = 0 ;
   45642             :   int result;
   45643             :   
   45644           1 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_refcount_get",&obj0)) SWIG_fail;
   45645           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45646           1 :   if (!SWIG_IsOK(res1)) {
   45647           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_refcount_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45648             :   }
   45649           1 :   arg1 = (struct symbolObj *)(argp1);
   45650           1 :   result = (int) ((arg1)->refcount);
   45651             :   resultobj = SWIG_From_int((int)(result));
   45652           1 :   return resultobj;
   45653           0 : fail:
   45654             :   return NULL;
   45655             : }
   45656             : 
   45657             : 
   45658           1 : SWIGINTERN PyObject *_wrap_symbolObj_numpoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45659             :   PyObject *resultobj = 0;
   45660             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45661           1 :   void *argp1 = 0 ;
   45662             :   int res1 = 0 ;
   45663           1 :   PyObject * obj0 = 0 ;
   45664             :   int result;
   45665             :   
   45666           1 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_numpoints_get",&obj0)) SWIG_fail;
   45667           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45668           1 :   if (!SWIG_IsOK(res1)) {
   45669           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_numpoints_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45670             :   }
   45671           1 :   arg1 = (struct symbolObj *)(argp1);
   45672           1 :   result = (int) ((arg1)->numpoints);
   45673             :   resultobj = SWIG_From_int((int)(result));
   45674           1 :   return resultobj;
   45675           0 : fail:
   45676             :   return NULL;
   45677             : }
   45678             : 
   45679             : 
   45680           0 : SWIGINTERN PyObject *_wrap_symbolObj_filled_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45681             :   PyObject *resultobj = 0;
   45682             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45683             :   int arg2 ;
   45684           0 :   void *argp1 = 0 ;
   45685             :   int res1 = 0 ;
   45686             :   int val2 ;
   45687             :   int ecode2 = 0 ;
   45688           0 :   PyObject * obj0 = 0 ;
   45689           0 :   PyObject * obj1 = 0 ;
   45690             :   
   45691           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_filled_set",&obj0,&obj1)) SWIG_fail;
   45692           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45693           0 :   if (!SWIG_IsOK(res1)) {
   45694           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_filled_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45695             :   }
   45696           0 :   arg1 = (struct symbolObj *)(argp1);
   45697           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   45698           0 :   if (!SWIG_IsOK(ecode2)) {
   45699           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_filled_set" "', argument " "2"" of type '" "int""'");
   45700             :   } 
   45701             :   arg2 = (int)(val2);
   45702           0 :   if (arg1) (arg1)->filled = arg2;
   45703             :   resultobj = SWIG_Py_Void();
   45704           0 :   return resultobj;
   45705           0 : fail:
   45706             :   return NULL;
   45707             : }
   45708             : 
   45709             : 
   45710           0 : SWIGINTERN PyObject *_wrap_symbolObj_filled_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45711             :   PyObject *resultobj = 0;
   45712             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45713           0 :   void *argp1 = 0 ;
   45714             :   int res1 = 0 ;
   45715           0 :   PyObject * obj0 = 0 ;
   45716             :   int result;
   45717             :   
   45718           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_filled_get",&obj0)) SWIG_fail;
   45719           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45720           0 :   if (!SWIG_IsOK(res1)) {
   45721           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_filled_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45722             :   }
   45723           0 :   arg1 = (struct symbolObj *)(argp1);
   45724           0 :   result = (int) ((arg1)->filled);
   45725             :   resultobj = SWIG_From_int((int)(result));
   45726           0 :   return resultobj;
   45727           0 : fail:
   45728             :   return NULL;
   45729             : }
   45730             : 
   45731             : 
   45732           0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45733             :   PyObject *resultobj = 0;
   45734             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45735             :   double arg2 ;
   45736           0 :   void *argp1 = 0 ;
   45737             :   int res1 = 0 ;
   45738             :   double val2 ;
   45739             :   int ecode2 = 0 ;
   45740           0 :   PyObject * obj0 = 0 ;
   45741           0 :   PyObject * obj1 = 0 ;
   45742             :   
   45743           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_anchorpoint_x_set",&obj0,&obj1)) SWIG_fail;
   45744           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45745           0 :   if (!SWIG_IsOK(res1)) {
   45746           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_x_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45747             :   }
   45748           0 :   arg1 = (struct symbolObj *)(argp1);
   45749           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45750           0 :   if (!SWIG_IsOK(ecode2)) {
   45751           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_anchorpoint_x_set" "', argument " "2"" of type '" "double""'");
   45752             :   } 
   45753           0 :   arg2 = (double)(val2);
   45754           0 :   if (arg1) (arg1)->anchorpoint_x = arg2;
   45755             :   resultobj = SWIG_Py_Void();
   45756           0 :   return resultobj;
   45757           0 : fail:
   45758             :   return NULL;
   45759             : }
   45760             : 
   45761             : 
   45762           0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45763             :   PyObject *resultobj = 0;
   45764             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45765           0 :   void *argp1 = 0 ;
   45766             :   int res1 = 0 ;
   45767           0 :   PyObject * obj0 = 0 ;
   45768             :   double result;
   45769             :   
   45770           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_anchorpoint_x_get",&obj0)) SWIG_fail;
   45771           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45772           0 :   if (!SWIG_IsOK(res1)) {
   45773           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_x_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45774             :   }
   45775           0 :   arg1 = (struct symbolObj *)(argp1);
   45776           0 :   result = (double) ((arg1)->anchorpoint_x);
   45777           0 :   resultobj = SWIG_From_double((double)(result));
   45778           0 :   return resultobj;
   45779           0 : fail:
   45780             :   return NULL;
   45781             : }
   45782             : 
   45783             : 
   45784           0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45785             :   PyObject *resultobj = 0;
   45786             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45787             :   double arg2 ;
   45788           0 :   void *argp1 = 0 ;
   45789             :   int res1 = 0 ;
   45790             :   double val2 ;
   45791             :   int ecode2 = 0 ;
   45792           0 :   PyObject * obj0 = 0 ;
   45793           0 :   PyObject * obj1 = 0 ;
   45794             :   
   45795           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_anchorpoint_y_set",&obj0,&obj1)) SWIG_fail;
   45796           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45797           0 :   if (!SWIG_IsOK(res1)) {
   45798           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_y_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45799             :   }
   45800           0 :   arg1 = (struct symbolObj *)(argp1);
   45801           0 :   ecode2 = SWIG_AsVal_double(obj1, &val2);
   45802           0 :   if (!SWIG_IsOK(ecode2)) {
   45803           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_anchorpoint_y_set" "', argument " "2"" of type '" "double""'");
   45804             :   } 
   45805           0 :   arg2 = (double)(val2);
   45806           0 :   if (arg1) (arg1)->anchorpoint_y = arg2;
   45807             :   resultobj = SWIG_Py_Void();
   45808           0 :   return resultobj;
   45809           0 : fail:
   45810             :   return NULL;
   45811             : }
   45812             : 
   45813             : 
   45814           0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45815             :   PyObject *resultobj = 0;
   45816             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45817           0 :   void *argp1 = 0 ;
   45818             :   int res1 = 0 ;
   45819           0 :   PyObject * obj0 = 0 ;
   45820             :   double result;
   45821             :   
   45822           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_anchorpoint_y_get",&obj0)) SWIG_fail;
   45823           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45824           0 :   if (!SWIG_IsOK(res1)) {
   45825           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_y_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45826             :   }
   45827           0 :   arg1 = (struct symbolObj *)(argp1);
   45828           0 :   result = (double) ((arg1)->anchorpoint_y);
   45829           0 :   resultobj = SWIG_From_double((double)(result));
   45830           0 :   return resultobj;
   45831           0 : fail:
   45832             :   return NULL;
   45833             : }
   45834             : 
   45835             : 
   45836           0 : SWIGINTERN PyObject *_wrap_symbolObj_imagepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45837             :   PyObject *resultobj = 0;
   45838             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45839           0 :   void *argp1 = 0 ;
   45840             :   int res1 = 0 ;
   45841           0 :   PyObject * obj0 = 0 ;
   45842             :   char *result = 0 ;
   45843             :   
   45844           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_imagepath_get",&obj0)) SWIG_fail;
   45845           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45846           0 :   if (!SWIG_IsOK(res1)) {
   45847           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_imagepath_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45848             :   }
   45849           0 :   arg1 = (struct symbolObj *)(argp1);
   45850           0 :   result = (char *) ((arg1)->imagepath);
   45851           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   45852           0 :   return resultobj;
   45853           0 : fail:
   45854             :   return NULL;
   45855             : }
   45856             : 
   45857             : 
   45858           0 : SWIGINTERN PyObject *_wrap_symbolObj_transparent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45859             :   PyObject *resultobj = 0;
   45860             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45861             :   int arg2 ;
   45862           0 :   void *argp1 = 0 ;
   45863             :   int res1 = 0 ;
   45864             :   int val2 ;
   45865             :   int ecode2 = 0 ;
   45866           0 :   PyObject * obj0 = 0 ;
   45867           0 :   PyObject * obj1 = 0 ;
   45868             :   
   45869           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_transparent_set",&obj0,&obj1)) SWIG_fail;
   45870           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45871           0 :   if (!SWIG_IsOK(res1)) {
   45872           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparent_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45873             :   }
   45874           0 :   arg1 = (struct symbolObj *)(argp1);
   45875           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   45876           0 :   if (!SWIG_IsOK(ecode2)) {
   45877           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_transparent_set" "', argument " "2"" of type '" "int""'");
   45878             :   } 
   45879             :   arg2 = (int)(val2);
   45880           0 :   if (arg1) (arg1)->transparent = arg2;
   45881             :   resultobj = SWIG_Py_Void();
   45882           0 :   return resultobj;
   45883           0 : fail:
   45884             :   return NULL;
   45885             : }
   45886             : 
   45887             : 
   45888           0 : SWIGINTERN PyObject *_wrap_symbolObj_transparent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45889             :   PyObject *resultobj = 0;
   45890             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45891           0 :   void *argp1 = 0 ;
   45892             :   int res1 = 0 ;
   45893           0 :   PyObject * obj0 = 0 ;
   45894             :   int result;
   45895             :   
   45896           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_transparent_get",&obj0)) SWIG_fail;
   45897           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45898           0 :   if (!SWIG_IsOK(res1)) {
   45899           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparent_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45900             :   }
   45901           0 :   arg1 = (struct symbolObj *)(argp1);
   45902           0 :   result = (int) ((arg1)->transparent);
   45903             :   resultobj = SWIG_From_int((int)(result));
   45904           0 :   return resultobj;
   45905           0 : fail:
   45906             :   return NULL;
   45907             : }
   45908             : 
   45909             : 
   45910           0 : SWIGINTERN PyObject *_wrap_symbolObj_transparentcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45911             :   PyObject *resultobj = 0;
   45912             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45913             :   int arg2 ;
   45914           0 :   void *argp1 = 0 ;
   45915             :   int res1 = 0 ;
   45916             :   int val2 ;
   45917             :   int ecode2 = 0 ;
   45918           0 :   PyObject * obj0 = 0 ;
   45919           0 :   PyObject * obj1 = 0 ;
   45920             :   
   45921           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_transparentcolor_set",&obj0,&obj1)) SWIG_fail;
   45922           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45923           0 :   if (!SWIG_IsOK(res1)) {
   45924           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparentcolor_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45925             :   }
   45926           0 :   arg1 = (struct symbolObj *)(argp1);
   45927           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   45928           0 :   if (!SWIG_IsOK(ecode2)) {
   45929           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_transparentcolor_set" "', argument " "2"" of type '" "int""'");
   45930             :   } 
   45931             :   arg2 = (int)(val2);
   45932           0 :   if (arg1) (arg1)->transparentcolor = arg2;
   45933             :   resultobj = SWIG_Py_Void();
   45934           0 :   return resultobj;
   45935           0 : fail:
   45936             :   return NULL;
   45937             : }
   45938             : 
   45939             : 
   45940           0 : SWIGINTERN PyObject *_wrap_symbolObj_transparentcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45941             :   PyObject *resultobj = 0;
   45942             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45943           0 :   void *argp1 = 0 ;
   45944             :   int res1 = 0 ;
   45945           0 :   PyObject * obj0 = 0 ;
   45946             :   int result;
   45947             :   
   45948           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_transparentcolor_get",&obj0)) SWIG_fail;
   45949           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45950           0 :   if (!SWIG_IsOK(res1)) {
   45951           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparentcolor_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45952             :   }
   45953           0 :   arg1 = (struct symbolObj *)(argp1);
   45954           0 :   result = (int) ((arg1)->transparentcolor);
   45955             :   resultobj = SWIG_From_int((int)(result));
   45956           0 :   return resultobj;
   45957           0 : fail:
   45958             :   return NULL;
   45959             : }
   45960             : 
   45961             : 
   45962           0 : SWIGINTERN PyObject *_wrap_symbolObj_character_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   45963             :   PyObject *resultobj = 0;
   45964             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   45965             :   char *arg2 = (char *) 0 ;
   45966           0 :   void *argp1 = 0 ;
   45967             :   int res1 = 0 ;
   45968             :   int res2 ;
   45969           0 :   char *buf2 = 0 ;
   45970           0 :   int alloc2 = 0 ;
   45971           0 :   PyObject * obj0 = 0 ;
   45972           0 :   PyObject * obj1 = 0 ;
   45973             :   
   45974           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_character_set",&obj0,&obj1)) SWIG_fail;
   45975           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   45976           0 :   if (!SWIG_IsOK(res1)) {
   45977           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_character_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   45978             :   }
   45979           0 :   arg1 = (struct symbolObj *)(argp1);
   45980           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   45981           0 :   if (!SWIG_IsOK(res2)) {
   45982           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_character_set" "', argument " "2"" of type '" "char *""'");
   45983             :   }
   45984           0 :   arg2 = (char *)(buf2);
   45985             :   {
   45986           0 :     if (arg1->character) free((char*)arg1->character);
   45987           0 :     if (arg2) {
   45988           0 :       arg1->character = (char *) malloc(strlen(arg2)+1);
   45989             :       strcpy((char*)arg1->character,arg2);
   45990             :     } else {
   45991           0 :       arg1->character = 0;
   45992             :     }
   45993             :   }
   45994             :   resultobj = SWIG_Py_Void();
   45995           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   45996             :   return resultobj;
   45997           0 : fail:
   45998           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   45999             :   return NULL;
   46000             : }
   46001             : 
   46002             : 
   46003           0 : SWIGINTERN PyObject *_wrap_symbolObj_character_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46004             :   PyObject *resultobj = 0;
   46005             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46006           0 :   void *argp1 = 0 ;
   46007             :   int res1 = 0 ;
   46008           0 :   PyObject * obj0 = 0 ;
   46009             :   char *result = 0 ;
   46010             :   
   46011           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_character_get",&obj0)) SWIG_fail;
   46012           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46013           0 :   if (!SWIG_IsOK(res1)) {
   46014           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_character_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46015             :   }
   46016           0 :   arg1 = (struct symbolObj *)(argp1);
   46017           0 :   result = (char *) ((arg1)->character);
   46018           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   46019           0 :   return resultobj;
   46020           0 : fail:
   46021             :   return NULL;
   46022             : }
   46023             : 
   46024             : 
   46025           0 : SWIGINTERN PyObject *_wrap_symbolObj_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46026             :   PyObject *resultobj = 0;
   46027             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46028             :   char *arg2 = (char *) 0 ;
   46029           0 :   void *argp1 = 0 ;
   46030             :   int res1 = 0 ;
   46031             :   int res2 ;
   46032           0 :   char *buf2 = 0 ;
   46033           0 :   int alloc2 = 0 ;
   46034           0 :   PyObject * obj0 = 0 ;
   46035           0 :   PyObject * obj1 = 0 ;
   46036             :   
   46037           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_font_set",&obj0,&obj1)) SWIG_fail;
   46038           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46039           0 :   if (!SWIG_IsOK(res1)) {
   46040           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_font_set" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46041             :   }
   46042           0 :   arg1 = (struct symbolObj *)(argp1);
   46043           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46044           0 :   if (!SWIG_IsOK(res2)) {
   46045           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_font_set" "', argument " "2"" of type '" "char *""'");
   46046             :   }
   46047           0 :   arg2 = (char *)(buf2);
   46048             :   {
   46049           0 :     if (arg1->font) free((char*)arg1->font);
   46050           0 :     if (arg2) {
   46051           0 :       arg1->font = (char *) malloc(strlen(arg2)+1);
   46052             :       strcpy((char*)arg1->font,arg2);
   46053             :     } else {
   46054           0 :       arg1->font = 0;
   46055             :     }
   46056             :   }
   46057             :   resultobj = SWIG_Py_Void();
   46058           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46059             :   return resultobj;
   46060           0 : fail:
   46061           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46062             :   return NULL;
   46063             : }
   46064             : 
   46065             : 
   46066           0 : SWIGINTERN PyObject *_wrap_symbolObj_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46067             :   PyObject *resultobj = 0;
   46068             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46069           0 :   void *argp1 = 0 ;
   46070             :   int res1 = 0 ;
   46071           0 :   PyObject * obj0 = 0 ;
   46072             :   char *result = 0 ;
   46073             :   
   46074           0 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_font_get",&obj0)) SWIG_fail;
   46075           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46076           0 :   if (!SWIG_IsOK(res1)) {
   46077           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_font_get" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46078             :   }
   46079           0 :   arg1 = (struct symbolObj *)(argp1);
   46080           0 :   result = (char *) ((arg1)->font);
   46081           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   46082           0 :   return resultobj;
   46083           0 : fail:
   46084             :   return NULL;
   46085             : }
   46086             : 
   46087             : 
   46088           1 : SWIGINTERN PyObject *_wrap_new_symbolObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46089             :   PyObject *resultobj = 0;
   46090             :   char *arg1 = (char *) 0 ;
   46091             :   char *arg2 = (char *) NULL ;
   46092             :   int res1 ;
   46093           1 :   char *buf1 = 0 ;
   46094           1 :   int alloc1 = 0 ;
   46095             :   int res2 ;
   46096           1 :   char *buf2 = 0 ;
   46097           1 :   int alloc2 = 0 ;
   46098           1 :   PyObject * obj0 = 0 ;
   46099           1 :   PyObject * obj1 = 0 ;
   46100             :   struct symbolObj *result = 0 ;
   46101             :   
   46102           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:new_symbolObj",&obj0,&obj1)) SWIG_fail;
   46103           1 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   46104           1 :   if (!SWIG_IsOK(res1)) {
   46105           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_symbolObj" "', argument " "1"" of type '" "char *""'");
   46106             :   }
   46107           1 :   arg1 = (char *)(buf1);
   46108           1 :   if (obj1) {
   46109           1 :     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46110           1 :     if (!SWIG_IsOK(res2)) {
   46111           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_symbolObj" "', argument " "2"" of type '" "char const *""'");
   46112             :     }
   46113           1 :     arg2 = (char *)(buf2);
   46114             :   }
   46115             :   {
   46116           1 :     result = (struct symbolObj *)new_symbolObj(arg1,(char const *)arg2); {
   46117           1 :       errorObj *ms_error = msGetErrorObj();
   46118             :       
   46119           1 :       switch(ms_error->code) {
   46120             :       case MS_NOERR:
   46121             :         break;
   46122           0 :       case MS_NOTFOUND:
   46123           0 :         msResetErrorList();
   46124           0 :         break;
   46125             :       case -1:
   46126             :         break;
   46127           0 :       case MS_IOERR:
   46128           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46129           0 :           _raise_ms_exception();
   46130           0 :           msResetErrorList();
   46131           0 :           return NULL;
   46132             :         }
   46133             :       default:
   46134           0 :         _raise_ms_exception();
   46135           0 :         msResetErrorList();
   46136           0 :         return NULL;
   46137             :       }
   46138             :       
   46139             :     }
   46140             :   }
   46141           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_NEW |  0 );
   46142           1 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   46143           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46144             :   return resultobj;
   46145           0 : fail:
   46146           0 :   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
   46147           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46148             :   return NULL;
   46149             : }
   46150             : 
   46151             : 
   46152           1 : SWIGINTERN PyObject *_wrap_delete_symbolObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46153             :   PyObject *resultobj = 0;
   46154             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46155           1 :   void *argp1 = 0 ;
   46156             :   int res1 = 0 ;
   46157           1 :   PyObject * obj0 = 0 ;
   46158             :   
   46159           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_symbolObj",&obj0)) SWIG_fail;
   46160           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, SWIG_POINTER_DISOWN |  0 );
   46161           1 :   if (!SWIG_IsOK(res1)) {
   46162           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_symbolObj" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46163             :   }
   46164           1 :   arg1 = (struct symbolObj *)(argp1);
   46165             :   {
   46166           1 :     delete_symbolObj(arg1); {
   46167           1 :       errorObj *ms_error = msGetErrorObj();
   46168             :       
   46169           1 :       switch(ms_error->code) {
   46170             :       case MS_NOERR:
   46171             :         break;
   46172           0 :       case MS_NOTFOUND:
   46173           0 :         msResetErrorList();
   46174           0 :         break;
   46175             :       case -1:
   46176             :         break;
   46177           0 :       case MS_IOERR:
   46178           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46179           0 :           _raise_ms_exception();
   46180           0 :           msResetErrorList();
   46181           0 :           return NULL;
   46182             :         }
   46183             :       default:
   46184           0 :         _raise_ms_exception();
   46185           0 :         msResetErrorList();
   46186           0 :         return NULL;
   46187             :       }
   46188             :       
   46189             :     }
   46190             :   }
   46191             :   resultobj = SWIG_Py_Void();
   46192           1 :   return resultobj;
   46193           0 : fail:
   46194             :   return NULL;
   46195             : }
   46196             : 
   46197             : 
   46198           1 : SWIGINTERN PyObject *_wrap_symbolObj_setImagepath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46199             :   PyObject *resultobj = 0;
   46200             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46201             :   char *arg2 = (char *) 0 ;
   46202           1 :   void *argp1 = 0 ;
   46203             :   int res1 = 0 ;
   46204             :   int res2 ;
   46205           1 :   char *buf2 = 0 ;
   46206           1 :   int alloc2 = 0 ;
   46207           1 :   PyObject * obj0 = 0 ;
   46208           1 :   PyObject * obj1 = 0 ;
   46209             :   int result;
   46210             :   
   46211           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_setImagepath",&obj0,&obj1)) SWIG_fail;
   46212           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46213           1 :   if (!SWIG_IsOK(res1)) {
   46214           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_setImagepath" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46215             :   }
   46216           1 :   arg1 = (struct symbolObj *)(argp1);
   46217           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46218           1 :   if (!SWIG_IsOK(res2)) {
   46219           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_setImagepath" "', argument " "2"" of type '" "char const *""'");
   46220             :   }
   46221           1 :   arg2 = (char *)(buf2);
   46222             :   {
   46223             :     result = (int)symbolObj_setImagepath(arg1,(char const *)arg2); {
   46224           1 :       errorObj *ms_error = msGetErrorObj();
   46225             :       
   46226           1 :       switch(ms_error->code) {
   46227             :       case MS_NOERR:
   46228             :         break;
   46229           0 :       case MS_NOTFOUND:
   46230           0 :         msResetErrorList();
   46231           0 :         break;
   46232             :       case -1:
   46233             :         break;
   46234           0 :       case MS_IOERR:
   46235           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46236           0 :           _raise_ms_exception();
   46237           0 :           msResetErrorList();
   46238           0 :           return NULL;
   46239             :         }
   46240             :       default:
   46241           0 :         _raise_ms_exception();
   46242           0 :         msResetErrorList();
   46243           0 :         return NULL;
   46244             :       }
   46245             :       
   46246             :     }
   46247             :   }
   46248             :   resultobj = SWIG_From_int((int)(result));
   46249           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46250             :   return resultobj;
   46251           0 : fail:
   46252           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46253             :   return NULL;
   46254             : }
   46255             : 
   46256             : 
   46257           1 : SWIGINTERN PyObject *_wrap_symbolObj_setPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46258             :   PyObject *resultobj = 0;
   46259             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46260             :   lineObj *arg2 = (lineObj *) 0 ;
   46261           1 :   void *argp1 = 0 ;
   46262             :   int res1 = 0 ;
   46263           1 :   void *argp2 = 0 ;
   46264             :   int res2 = 0 ;
   46265           1 :   PyObject * obj0 = 0 ;
   46266           1 :   PyObject * obj1 = 0 ;
   46267             :   int result;
   46268             :   
   46269           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_setPoints",&obj0,&obj1)) SWIG_fail;
   46270           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46271           1 :   if (!SWIG_IsOK(res1)) {
   46272           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_setPoints" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46273             :   }
   46274           1 :   arg1 = (struct symbolObj *)(argp1);
   46275           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_lineObj, 0 |  0 );
   46276           1 :   if (!SWIG_IsOK(res2)) {
   46277           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_setPoints" "', argument " "2"" of type '" "lineObj *""'"); 
   46278             :   }
   46279           1 :   arg2 = (lineObj *)(argp2);
   46280             :   {
   46281           1 :     result = (int)symbolObj_setPoints(arg1,arg2); {
   46282           1 :       errorObj *ms_error = msGetErrorObj();
   46283             :       
   46284           1 :       switch(ms_error->code) {
   46285             :       case MS_NOERR:
   46286             :         break;
   46287           0 :       case MS_NOTFOUND:
   46288           0 :         msResetErrorList();
   46289           0 :         break;
   46290             :       case -1:
   46291             :         break;
   46292           0 :       case MS_IOERR:
   46293           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46294           0 :           _raise_ms_exception();
   46295           0 :           msResetErrorList();
   46296           0 :           return NULL;
   46297             :         }
   46298             :       default:
   46299           0 :         _raise_ms_exception();
   46300           0 :         msResetErrorList();
   46301           0 :         return NULL;
   46302             :       }
   46303             :       
   46304             :     }
   46305             :   }
   46306             :   resultobj = SWIG_From_int((int)(result));
   46307           1 :   return resultobj;
   46308           0 : fail:
   46309             :   return NULL;
   46310             : }
   46311             : 
   46312             : 
   46313           1 : SWIGINTERN PyObject *_wrap_symbolObj_getPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46314             :   PyObject *resultobj = 0;
   46315             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46316           1 :   void *argp1 = 0 ;
   46317             :   int res1 = 0 ;
   46318           1 :   PyObject * obj0 = 0 ;
   46319             :   lineObj *result = 0 ;
   46320             :   
   46321           1 :   if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_getPoints",&obj0)) SWIG_fail;
   46322           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46323           1 :   if (!SWIG_IsOK(res1)) {
   46324           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_getPoints" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46325             :   }
   46326           1 :   arg1 = (struct symbolObj *)(argp1);
   46327             :   {
   46328           1 :     result = (lineObj *)symbolObj_getPoints(arg1); {
   46329           1 :       errorObj *ms_error = msGetErrorObj();
   46330             :       
   46331           1 :       switch(ms_error->code) {
   46332             :       case MS_NOERR:
   46333             :         break;
   46334           0 :       case MS_NOTFOUND:
   46335           0 :         msResetErrorList();
   46336           0 :         break;
   46337             :       case -1:
   46338             :         break;
   46339           0 :       case MS_IOERR:
   46340           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46341           0 :           _raise_ms_exception();
   46342           0 :           msResetErrorList();
   46343           0 :           return NULL;
   46344             :         }
   46345             :       default:
   46346           0 :         _raise_ms_exception();
   46347           0 :         msResetErrorList();
   46348           0 :         return NULL;
   46349             :       }
   46350             :       
   46351             :     }
   46352             :   }
   46353           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, SWIG_POINTER_OWN |  0 );
   46354           1 :   return resultobj;
   46355           0 : fail:
   46356             :   return NULL;
   46357             : }
   46358             : 
   46359             : 
   46360           1 : SWIGINTERN PyObject *_wrap_symbolObj_getImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46361             :   PyObject *resultobj = 0;
   46362             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46363             :   outputFormatObj *arg2 = (outputFormatObj *) 0 ;
   46364           1 :   void *argp1 = 0 ;
   46365             :   int res1 = 0 ;
   46366           1 :   void *argp2 = 0 ;
   46367             :   int res2 = 0 ;
   46368           1 :   PyObject * obj0 = 0 ;
   46369           1 :   PyObject * obj1 = 0 ;
   46370             :   imageObj *result = 0 ;
   46371             :   
   46372           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_getImage",&obj0,&obj1)) SWIG_fail;
   46373           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46374           1 :   if (!SWIG_IsOK(res1)) {
   46375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_getImage" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46376             :   }
   46377           1 :   arg1 = (struct symbolObj *)(argp1);
   46378           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_outputFormatObj, 0 |  0 );
   46379           1 :   if (!SWIG_IsOK(res2)) {
   46380           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_getImage" "', argument " "2"" of type '" "outputFormatObj *""'"); 
   46381             :   }
   46382           1 :   arg2 = (outputFormatObj *)(argp2);
   46383             :   {
   46384           1 :     result = (imageObj *)symbolObj_getImage(arg1,arg2); {
   46385           1 :       errorObj *ms_error = msGetErrorObj();
   46386             :       
   46387           1 :       switch(ms_error->code) {
   46388             :       case MS_NOERR:
   46389             :         break;
   46390           0 :       case MS_NOTFOUND:
   46391           0 :         msResetErrorList();
   46392           0 :         break;
   46393             :       case -1:
   46394             :         break;
   46395           0 :       case MS_IOERR:
   46396           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46397           0 :           _raise_ms_exception();
   46398           0 :           msResetErrorList();
   46399           0 :           return NULL;
   46400             :         }
   46401             :       default:
   46402           0 :         _raise_ms_exception();
   46403           0 :         msResetErrorList();
   46404           0 :         return NULL;
   46405             :       }
   46406             :       
   46407             :     }
   46408             :   }
   46409           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN |  0 );
   46410           1 :   return resultobj;
   46411           0 : fail:
   46412             :   return NULL;
   46413             : }
   46414             : 
   46415             : 
   46416           0 : SWIGINTERN PyObject *_wrap_symbolObj_setImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46417             :   PyObject *resultobj = 0;
   46418             :   struct symbolObj *arg1 = (struct symbolObj *) 0 ;
   46419             :   imageObj *arg2 = (imageObj *) 0 ;
   46420           0 :   void *argp1 = 0 ;
   46421             :   int res1 = 0 ;
   46422           0 :   void *argp2 = 0 ;
   46423             :   int res2 = 0 ;
   46424           0 :   PyObject * obj0 = 0 ;
   46425           0 :   PyObject * obj1 = 0 ;
   46426             :   int result;
   46427             :   
   46428           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_setImage",&obj0,&obj1)) SWIG_fail;
   46429           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 |  0 );
   46430           0 :   if (!SWIG_IsOK(res1)) {
   46431           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_setImage" "', argument " "1"" of type '" "struct symbolObj *""'"); 
   46432             :   }
   46433           0 :   arg1 = (struct symbolObj *)(argp1);
   46434           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 |  0 );
   46435           0 :   if (!SWIG_IsOK(res2)) {
   46436           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_setImage" "', argument " "2"" of type '" "imageObj *""'"); 
   46437             :   }
   46438           0 :   arg2 = (imageObj *)(argp2);
   46439             :   {
   46440           0 :     result = (int)symbolObj_setImage(arg1,arg2); {
   46441           0 :       errorObj *ms_error = msGetErrorObj();
   46442             :       
   46443           0 :       switch(ms_error->code) {
   46444             :       case MS_NOERR:
   46445             :         break;
   46446           0 :       case MS_NOTFOUND:
   46447           0 :         msResetErrorList();
   46448           0 :         break;
   46449             :       case -1:
   46450             :         break;
   46451           0 :       case MS_IOERR:
   46452           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46453           0 :           _raise_ms_exception();
   46454           0 :           msResetErrorList();
   46455           0 :           return NULL;
   46456             :         }
   46457             :       default:
   46458           0 :         _raise_ms_exception();
   46459           0 :         msResetErrorList();
   46460           0 :         return NULL;
   46461             :       }
   46462             :       
   46463             :     }
   46464             :   }
   46465             :   resultobj = SWIG_From_int((int)(result));
   46466           0 :   return resultobj;
   46467           0 : fail:
   46468             :   return NULL;
   46469             : }
   46470             : 
   46471             : 
   46472           1 : SWIGINTERN PyObject *symbolObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46473             :   PyObject *obj;
   46474           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   46475           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_symbolObj, SWIG_NewClientData(obj));
   46476           1 :   return SWIG_Py_Void();
   46477             : }
   46478             : 
   46479           1 : SWIGINTERN PyObject *_wrap_hashTableObj_numitems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46480             :   PyObject *resultobj = 0;
   46481             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46482           1 :   void *argp1 = 0 ;
   46483             :   int res1 = 0 ;
   46484           1 :   PyObject * obj0 = 0 ;
   46485             :   int result;
   46486             :   
   46487           1 :   if (!PyArg_ParseTuple(args,(char *)"O:hashTableObj_numitems_get",&obj0)) SWIG_fail;
   46488           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 |  0 );
   46489           1 :   if (!SWIG_IsOK(res1)) {
   46490           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_numitems_get" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46491             :   }
   46492           1 :   arg1 = (hashTableObj *)(argp1);
   46493           1 :   result = (int) ((arg1)->numitems);
   46494             :   resultobj = SWIG_From_int((int)(result));
   46495           1 :   return resultobj;
   46496           0 : fail:
   46497             :   return NULL;
   46498             : }
   46499             : 
   46500             : 
   46501           1 : SWIGINTERN PyObject *_wrap_new_hashTableObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46502             :   PyObject *resultobj = 0;
   46503             :   hashTableObj *result = 0 ;
   46504             :   
   46505           1 :   if (!PyArg_ParseTuple(args,(char *)":new_hashTableObj")) SWIG_fail;
   46506             :   {
   46507             :     result = (hashTableObj *)new_hashTableObj(); {
   46508           1 :       errorObj *ms_error = msGetErrorObj();
   46509             :       
   46510           1 :       switch(ms_error->code) {
   46511             :       case MS_NOERR:
   46512             :         break;
   46513           0 :       case MS_NOTFOUND:
   46514           0 :         msResetErrorList();
   46515           0 :         break;
   46516             :       case -1:
   46517             :         break;
   46518           0 :       case MS_IOERR:
   46519           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46520           0 :           _raise_ms_exception();
   46521           0 :           msResetErrorList();
   46522           0 :           return NULL;
   46523             :         }
   46524             :       default:
   46525           0 :         _raise_ms_exception();
   46526           0 :         msResetErrorList();
   46527           0 :         return NULL;
   46528             :       }
   46529             :       
   46530             :     }
   46531             :   }
   46532           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, SWIG_POINTER_NEW |  0 );
   46533           1 :   return resultobj;
   46534           1 : fail:
   46535             :   return NULL;
   46536             : }
   46537             : 
   46538             : 
   46539           1 : SWIGINTERN PyObject *_wrap_delete_hashTableObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46540             :   PyObject *resultobj = 0;
   46541             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46542           1 :   void *argp1 = 0 ;
   46543             :   int res1 = 0 ;
   46544           1 :   PyObject * obj0 = 0 ;
   46545             :   
   46546           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_hashTableObj",&obj0)) SWIG_fail;
   46547           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, SWIG_POINTER_DISOWN |  0 );
   46548           1 :   if (!SWIG_IsOK(res1)) {
   46549           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_hashTableObj" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46550             :   }
   46551           1 :   arg1 = (hashTableObj *)(argp1);
   46552             :   {
   46553             :     delete_hashTableObj(arg1); {
   46554           1 :       errorObj *ms_error = msGetErrorObj();
   46555             :       
   46556           1 :       switch(ms_error->code) {
   46557             :       case MS_NOERR:
   46558             :         break;
   46559           0 :       case MS_NOTFOUND:
   46560           0 :         msResetErrorList();
   46561           0 :         break;
   46562             :       case -1:
   46563             :         break;
   46564           0 :       case MS_IOERR:
   46565           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46566           0 :           _raise_ms_exception();
   46567           0 :           msResetErrorList();
   46568           0 :           return NULL;
   46569             :         }
   46570             :       default:
   46571           0 :         _raise_ms_exception();
   46572           0 :         msResetErrorList();
   46573           0 :         return NULL;
   46574             :       }
   46575             :       
   46576             :     }
   46577             :   }
   46578             :   resultobj = SWIG_Py_Void();
   46579           1 :   return resultobj;
   46580           0 : fail:
   46581             :   return NULL;
   46582             : }
   46583             : 
   46584             : 
   46585           1 : SWIGINTERN PyObject *_wrap_hashTableObj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46586             :   PyObject *resultobj = 0;
   46587             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46588             :   char *arg2 = (char *) 0 ;
   46589             :   char *arg3 = (char *) 0 ;
   46590           1 :   void *argp1 = 0 ;
   46591             :   int res1 = 0 ;
   46592             :   int res2 ;
   46593           1 :   char *buf2 = 0 ;
   46594           1 :   int alloc2 = 0 ;
   46595             :   int res3 ;
   46596           1 :   char *buf3 = 0 ;
   46597           1 :   int alloc3 = 0 ;
   46598           1 :   PyObject * obj0 = 0 ;
   46599           1 :   PyObject * obj1 = 0 ;
   46600           1 :   PyObject * obj2 = 0 ;
   46601             :   int result;
   46602             :   
   46603           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:hashTableObj_set",&obj0,&obj1,&obj2)) SWIG_fail;
   46604           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 |  0 );
   46605           1 :   if (!SWIG_IsOK(res1)) {
   46606           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_set" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46607             :   }
   46608           1 :   arg1 = (hashTableObj *)(argp1);
   46609           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46610           1 :   if (!SWIG_IsOK(res2)) {
   46611           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_set" "', argument " "2"" of type '" "char *""'");
   46612             :   }
   46613           1 :   arg2 = (char *)(buf2);
   46614           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   46615           1 :   if (!SWIG_IsOK(res3)) {
   46616           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "hashTableObj_set" "', argument " "3"" of type '" "char *""'");
   46617             :   }
   46618           1 :   arg3 = (char *)(buf3);
   46619             :   {
   46620             :     result = (int)hashTableObj_set(arg1,arg2,arg3); {
   46621           1 :       errorObj *ms_error = msGetErrorObj();
   46622             :       
   46623           1 :       switch(ms_error->code) {
   46624             :       case MS_NOERR:
   46625             :         break;
   46626           0 :       case MS_NOTFOUND:
   46627           0 :         msResetErrorList();
   46628           0 :         break;
   46629             :       case -1:
   46630             :         break;
   46631           0 :       case MS_IOERR:
   46632           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46633           0 :           _raise_ms_exception();
   46634           0 :           msResetErrorList();
   46635           0 :           return NULL;
   46636             :         }
   46637             :       default:
   46638           0 :         _raise_ms_exception();
   46639           0 :         msResetErrorList();
   46640           0 :         return NULL;
   46641             :       }
   46642             :       
   46643             :     }
   46644             :   }
   46645             :   resultobj = SWIG_From_int((int)(result));
   46646           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46647           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   46648             :   return resultobj;
   46649           0 : fail:
   46650           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46651           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   46652             :   return NULL;
   46653             : }
   46654             : 
   46655             : 
   46656           1 : SWIGINTERN PyObject *_wrap_hashTableObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46657             :   PyObject *resultobj = 0;
   46658             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46659             :   char *arg2 = (char *) 0 ;
   46660             :   char *arg3 = (char *) NULL ;
   46661           1 :   void *argp1 = 0 ;
   46662             :   int res1 = 0 ;
   46663             :   int res2 ;
   46664           1 :   char *buf2 = 0 ;
   46665           1 :   int alloc2 = 0 ;
   46666             :   int res3 ;
   46667           1 :   char *buf3 = 0 ;
   46668           1 :   int alloc3 = 0 ;
   46669           1 :   PyObject * obj0 = 0 ;
   46670           1 :   PyObject * obj1 = 0 ;
   46671           1 :   PyObject * obj2 = 0 ;
   46672             :   char *result = 0 ;
   46673             :   
   46674           1 :   if (!PyArg_ParseTuple(args,(char *)"OO|O:hashTableObj_get",&obj0,&obj1,&obj2)) SWIG_fail;
   46675           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 |  0 );
   46676           1 :   if (!SWIG_IsOK(res1)) {
   46677           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_get" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46678             :   }
   46679           1 :   arg1 = (hashTableObj *)(argp1);
   46680           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46681           1 :   if (!SWIG_IsOK(res2)) {
   46682           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_get" "', argument " "2"" of type '" "char *""'");
   46683             :   }
   46684           1 :   arg2 = (char *)(buf2);
   46685           1 :   if (obj2) {
   46686           1 :     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   46687           1 :     if (!SWIG_IsOK(res3)) {
   46688           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "hashTableObj_get" "', argument " "3"" of type '" "char *""'");
   46689             :     }
   46690           1 :     arg3 = (char *)(buf3);
   46691             :   }
   46692             :   {
   46693           1 :     result = (char *)hashTableObj_get(arg1,arg2,arg3); {
   46694           1 :       errorObj *ms_error = msGetErrorObj();
   46695             :       
   46696           1 :       switch(ms_error->code) {
   46697             :       case MS_NOERR:
   46698             :         break;
   46699           0 :       case MS_NOTFOUND:
   46700           0 :         msResetErrorList();
   46701           0 :         break;
   46702             :       case -1:
   46703             :         break;
   46704           0 :       case MS_IOERR:
   46705           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46706           0 :           _raise_ms_exception();
   46707           0 :           msResetErrorList();
   46708           0 :           return NULL;
   46709             :         }
   46710             :       default:
   46711           0 :         _raise_ms_exception();
   46712           0 :         msResetErrorList();
   46713           0 :         return NULL;
   46714             :       }
   46715             :       
   46716             :     }
   46717             :   }
   46718           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   46719           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46720           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   46721             :   return resultobj;
   46722           0 : fail:
   46723           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46724           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   46725             :   return NULL;
   46726             : }
   46727             : 
   46728             : 
   46729           1 : SWIGINTERN PyObject *_wrap_hashTableObj_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46730             :   PyObject *resultobj = 0;
   46731             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46732             :   char *arg2 = (char *) 0 ;
   46733           1 :   void *argp1 = 0 ;
   46734             :   int res1 = 0 ;
   46735             :   int res2 ;
   46736           1 :   char *buf2 = 0 ;
   46737           1 :   int alloc2 = 0 ;
   46738           1 :   PyObject * obj0 = 0 ;
   46739           1 :   PyObject * obj1 = 0 ;
   46740             :   int result;
   46741             :   
   46742           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:hashTableObj_remove",&obj0,&obj1)) SWIG_fail;
   46743           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 |  0 );
   46744           1 :   if (!SWIG_IsOK(res1)) {
   46745           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_remove" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46746             :   }
   46747           1 :   arg1 = (hashTableObj *)(argp1);
   46748           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46749           1 :   if (!SWIG_IsOK(res2)) {
   46750           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_remove" "', argument " "2"" of type '" "char *""'");
   46751             :   }
   46752           1 :   arg2 = (char *)(buf2);
   46753             :   {
   46754             :     result = (int)hashTableObj_remove(arg1,arg2); {
   46755           1 :       errorObj *ms_error = msGetErrorObj();
   46756             :       
   46757           1 :       switch(ms_error->code) {
   46758             :       case MS_NOERR:
   46759             :         break;
   46760           0 :       case MS_NOTFOUND:
   46761           0 :         msResetErrorList();
   46762           0 :         break;
   46763             :       case -1:
   46764             :         break;
   46765           0 :       case MS_IOERR:
   46766           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46767           0 :           _raise_ms_exception();
   46768           0 :           msResetErrorList();
   46769           0 :           return NULL;
   46770             :         }
   46771             :       default:
   46772           0 :         _raise_ms_exception();
   46773           0 :         msResetErrorList();
   46774           0 :         return NULL;
   46775             :       }
   46776             :       
   46777             :     }
   46778             :   }
   46779             :   resultobj = SWIG_From_int((int)(result));
   46780           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46781             :   return resultobj;
   46782           0 : fail:
   46783           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46784             :   return NULL;
   46785             : }
   46786             : 
   46787             : 
   46788           1 : SWIGINTERN PyObject *_wrap_hashTableObj_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46789             :   PyObject *resultobj = 0;
   46790             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46791           1 :   void *argp1 = 0 ;
   46792             :   int res1 = 0 ;
   46793           1 :   PyObject * obj0 = 0 ;
   46794             :   
   46795           1 :   if (!PyArg_ParseTuple(args,(char *)"O:hashTableObj_clear",&obj0)) SWIG_fail;
   46796           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 |  0 );
   46797           1 :   if (!SWIG_IsOK(res1)) {
   46798           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_clear" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46799             :   }
   46800           1 :   arg1 = (hashTableObj *)(argp1);
   46801             :   {
   46802             :     hashTableObj_clear(arg1); {
   46803           1 :       errorObj *ms_error = msGetErrorObj();
   46804             :       
   46805           1 :       switch(ms_error->code) {
   46806             :       case MS_NOERR:
   46807             :         break;
   46808           0 :       case MS_NOTFOUND:
   46809           0 :         msResetErrorList();
   46810           0 :         break;
   46811             :       case -1:
   46812             :         break;
   46813           0 :       case MS_IOERR:
   46814           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46815           0 :           _raise_ms_exception();
   46816           0 :           msResetErrorList();
   46817           0 :           return NULL;
   46818             :         }
   46819             :       default:
   46820           0 :         _raise_ms_exception();
   46821           0 :         msResetErrorList();
   46822           0 :         return NULL;
   46823             :       }
   46824             :       
   46825             :     }
   46826             :   }
   46827             :   resultobj = SWIG_Py_Void();
   46828           1 :   return resultobj;
   46829           0 : fail:
   46830             :   return NULL;
   46831             : }
   46832             : 
   46833             : 
   46834           1 : SWIGINTERN PyObject *_wrap_hashTableObj_nextKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46835             :   PyObject *resultobj = 0;
   46836             :   hashTableObj *arg1 = (hashTableObj *) 0 ;
   46837             :   char *arg2 = (char *) NULL ;
   46838           1 :   void *argp1 = 0 ;
   46839             :   int res1 = 0 ;
   46840             :   int res2 ;
   46841           1 :   char *buf2 = 0 ;
   46842           1 :   int alloc2 = 0 ;
   46843           1 :   PyObject * obj0 = 0 ;
   46844           1 :   PyObject * obj1 = 0 ;
   46845             :   char *result = 0 ;
   46846             :   
   46847           1 :   if (!PyArg_ParseTuple(args,(char *)"O|O:hashTableObj_nextKey",&obj0,&obj1)) SWIG_fail;
   46848           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 |  0 );
   46849           1 :   if (!SWIG_IsOK(res1)) {
   46850           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_nextKey" "', argument " "1"" of type '" "hashTableObj *""'"); 
   46851             :   }
   46852           1 :   arg1 = (hashTableObj *)(argp1);
   46853           1 :   if (obj1) {
   46854           1 :     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46855           1 :     if (!SWIG_IsOK(res2)) {
   46856           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_nextKey" "', argument " "2"" of type '" "char *""'");
   46857             :     }
   46858           1 :     arg2 = (char *)(buf2);
   46859             :   }
   46860             :   {
   46861             :     result = (char *)hashTableObj_nextKey(arg1,arg2); {
   46862           1 :       errorObj *ms_error = msGetErrorObj();
   46863             :       
   46864           1 :       switch(ms_error->code) {
   46865             :       case MS_NOERR:
   46866             :         break;
   46867           0 :       case MS_NOTFOUND:
   46868           0 :         msResetErrorList();
   46869           0 :         break;
   46870             :       case -1:
   46871             :         break;
   46872           0 :       case MS_IOERR:
   46873           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   46874           0 :           _raise_ms_exception();
   46875           0 :           msResetErrorList();
   46876           0 :           return NULL;
   46877             :         }
   46878             :       default:
   46879           0 :         _raise_ms_exception();
   46880           0 :         msResetErrorList();
   46881           0 :         return NULL;
   46882             :       }
   46883             :       
   46884             :     }
   46885             :   }
   46886           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   46887           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46888             :   return resultobj;
   46889           0 : fail:
   46890           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   46891             :   return NULL;
   46892             : }
   46893             : 
   46894             : 
   46895           1 : SWIGINTERN PyObject *hashTableObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46896             :   PyObject *obj;
   46897           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   46898           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_hashTableObj, SWIG_NewClientData(obj));
   46899           1 :   return SWIG_Py_Void();
   46900             : }
   46901             : 
   46902           1 : SWIGINTERN PyObject *_wrap_OWSRequest_NumParams_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46903             :   PyObject *resultobj = 0;
   46904             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   46905           1 :   void *argp1 = 0 ;
   46906             :   int res1 = 0 ;
   46907           1 :   PyObject * obj0 = 0 ;
   46908             :   int result;
   46909             :   
   46910           1 :   if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_NumParams_get",&obj0)) SWIG_fail;
   46911           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   46912           1 :   if (!SWIG_IsOK(res1)) {
   46913           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_NumParams_get" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   46914             :   }
   46915           1 :   arg1 = (cgiRequestObj *)(argp1);
   46916           1 :   result = (int) ((arg1)->NumParams);
   46917             :   resultobj = SWIG_From_int((int)(result));
   46918           1 :   return resultobj;
   46919           0 : fail:
   46920             :   return NULL;
   46921             : }
   46922             : 
   46923             : 
   46924           1 : SWIGINTERN PyObject *_wrap_OWSRequest_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46925             :   PyObject *resultobj = 0;
   46926             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   46927             :   enum MS_REQUEST_TYPE arg2 ;
   46928           1 :   void *argp1 = 0 ;
   46929             :   int res1 = 0 ;
   46930             :   int val2 ;
   46931             :   int ecode2 = 0 ;
   46932           1 :   PyObject * obj0 = 0 ;
   46933           1 :   PyObject * obj1 = 0 ;
   46934             :   
   46935           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_type_set",&obj0,&obj1)) SWIG_fail;
   46936           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   46937           1 :   if (!SWIG_IsOK(res1)) {
   46938           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_type_set" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   46939             :   }
   46940           1 :   arg1 = (cgiRequestObj *)(argp1);
   46941           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   46942           1 :   if (!SWIG_IsOK(ecode2)) {
   46943           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OWSRequest_type_set" "', argument " "2"" of type '" "enum MS_REQUEST_TYPE""'");
   46944             :   } 
   46945           1 :   arg2 = (enum MS_REQUEST_TYPE)(val2);
   46946           1 :   if (arg1) (arg1)->type = arg2;
   46947             :   resultobj = SWIG_Py_Void();
   46948           1 :   return resultobj;
   46949           0 : fail:
   46950             :   return NULL;
   46951             : }
   46952             : 
   46953             : 
   46954           0 : SWIGINTERN PyObject *_wrap_OWSRequest_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46955             :   PyObject *resultobj = 0;
   46956             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   46957           0 :   void *argp1 = 0 ;
   46958             :   int res1 = 0 ;
   46959           0 :   PyObject * obj0 = 0 ;
   46960             :   enum MS_REQUEST_TYPE result;
   46961             :   
   46962           0 :   if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_type_get",&obj0)) SWIG_fail;
   46963           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   46964           0 :   if (!SWIG_IsOK(res1)) {
   46965           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_type_get" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   46966             :   }
   46967           0 :   arg1 = (cgiRequestObj *)(argp1);
   46968           0 :   result = (enum MS_REQUEST_TYPE) ((arg1)->type);
   46969           0 :   resultobj = SWIG_From_int((int)(result));
   46970           0 :   return resultobj;
   46971           0 : fail:
   46972             :   return NULL;
   46973             : }
   46974             : 
   46975             : 
   46976           0 : SWIGINTERN PyObject *_wrap_OWSRequest_contenttype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   46977             :   PyObject *resultobj = 0;
   46978             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   46979             :   char *arg2 = (char *) 0 ;
   46980           0 :   void *argp1 = 0 ;
   46981             :   int res1 = 0 ;
   46982             :   int res2 ;
   46983           0 :   char *buf2 = 0 ;
   46984           0 :   int alloc2 = 0 ;
   46985           0 :   PyObject * obj0 = 0 ;
   46986           0 :   PyObject * obj1 = 0 ;
   46987             :   
   46988           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_contenttype_set",&obj0,&obj1)) SWIG_fail;
   46989           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   46990           0 :   if (!SWIG_IsOK(res1)) {
   46991           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_contenttype_set" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   46992             :   }
   46993           0 :   arg1 = (cgiRequestObj *)(argp1);
   46994           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   46995           0 :   if (!SWIG_IsOK(res2)) {
   46996           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_contenttype_set" "', argument " "2"" of type '" "char *""'");
   46997             :   }
   46998           0 :   arg2 = (char *)(buf2);
   46999             :   {
   47000           0 :     if (arg1->contenttype) free((char*)arg1->contenttype);
   47001           0 :     if (arg2) {
   47002           0 :       arg1->contenttype = (char *) malloc(strlen(arg2)+1);
   47003             :       strcpy((char*)arg1->contenttype,arg2);
   47004             :     } else {
   47005           0 :       arg1->contenttype = 0;
   47006             :     }
   47007             :   }
   47008             :   resultobj = SWIG_Py_Void();
   47009           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47010             :   return resultobj;
   47011           0 : fail:
   47012           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47013             :   return NULL;
   47014             : }
   47015             : 
   47016             : 
   47017           0 : SWIGINTERN PyObject *_wrap_OWSRequest_contenttype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47018             :   PyObject *resultobj = 0;
   47019             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47020           0 :   void *argp1 = 0 ;
   47021             :   int res1 = 0 ;
   47022           0 :   PyObject * obj0 = 0 ;
   47023             :   char *result = 0 ;
   47024             :   
   47025           0 :   if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_contenttype_get",&obj0)) SWIG_fail;
   47026           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47027           0 :   if (!SWIG_IsOK(res1)) {
   47028           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_contenttype_get" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47029             :   }
   47030           0 :   arg1 = (cgiRequestObj *)(argp1);
   47031           0 :   result = (char *) ((arg1)->contenttype);
   47032           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47033           0 :   return resultobj;
   47034           0 : fail:
   47035             :   return NULL;
   47036             : }
   47037             : 
   47038             : 
   47039           0 : SWIGINTERN PyObject *_wrap_OWSRequest_postrequest_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47040             :   PyObject *resultobj = 0;
   47041             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47042             :   char *arg2 = (char *) 0 ;
   47043           0 :   void *argp1 = 0 ;
   47044             :   int res1 = 0 ;
   47045             :   int res2 ;
   47046           0 :   char *buf2 = 0 ;
   47047           0 :   int alloc2 = 0 ;
   47048           0 :   PyObject * obj0 = 0 ;
   47049           0 :   PyObject * obj1 = 0 ;
   47050             :   
   47051           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_postrequest_set",&obj0,&obj1)) SWIG_fail;
   47052           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47053           0 :   if (!SWIG_IsOK(res1)) {
   47054           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_postrequest_set" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47055             :   }
   47056           0 :   arg1 = (cgiRequestObj *)(argp1);
   47057           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   47058           0 :   if (!SWIG_IsOK(res2)) {
   47059           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_postrequest_set" "', argument " "2"" of type '" "char *""'");
   47060             :   }
   47061           0 :   arg2 = (char *)(buf2);
   47062             :   {
   47063           0 :     if (arg1->postrequest) free((char*)arg1->postrequest);
   47064           0 :     if (arg2) {
   47065           0 :       arg1->postrequest = (char *) malloc(strlen(arg2)+1);
   47066             :       strcpy((char*)arg1->postrequest,arg2);
   47067             :     } else {
   47068           0 :       arg1->postrequest = 0;
   47069             :     }
   47070             :   }
   47071             :   resultobj = SWIG_Py_Void();
   47072           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47073             :   return resultobj;
   47074           0 : fail:
   47075           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47076             :   return NULL;
   47077             : }
   47078             : 
   47079             : 
   47080           0 : SWIGINTERN PyObject *_wrap_OWSRequest_postrequest_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47081             :   PyObject *resultobj = 0;
   47082             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47083           0 :   void *argp1 = 0 ;
   47084             :   int res1 = 0 ;
   47085           0 :   PyObject * obj0 = 0 ;
   47086             :   char *result = 0 ;
   47087             :   
   47088           0 :   if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_postrequest_get",&obj0)) SWIG_fail;
   47089           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47090           0 :   if (!SWIG_IsOK(res1)) {
   47091           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_postrequest_get" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47092             :   }
   47093           0 :   arg1 = (cgiRequestObj *)(argp1);
   47094           0 :   result = (char *) ((arg1)->postrequest);
   47095           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47096           0 :   return resultobj;
   47097           0 : fail:
   47098             :   return NULL;
   47099             : }
   47100             : 
   47101             : 
   47102           0 : SWIGINTERN PyObject *_wrap_OWSRequest_httpcookiedata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47103             :   PyObject *resultobj = 0;
   47104             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47105             :   char *arg2 = (char *) 0 ;
   47106           0 :   void *argp1 = 0 ;
   47107             :   int res1 = 0 ;
   47108             :   int res2 ;
   47109           0 :   char *buf2 = 0 ;
   47110           0 :   int alloc2 = 0 ;
   47111           0 :   PyObject * obj0 = 0 ;
   47112           0 :   PyObject * obj1 = 0 ;
   47113             :   
   47114           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_httpcookiedata_set",&obj0,&obj1)) SWIG_fail;
   47115           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47116           0 :   if (!SWIG_IsOK(res1)) {
   47117           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_httpcookiedata_set" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47118             :   }
   47119           0 :   arg1 = (cgiRequestObj *)(argp1);
   47120           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   47121           0 :   if (!SWIG_IsOK(res2)) {
   47122           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_httpcookiedata_set" "', argument " "2"" of type '" "char *""'");
   47123             :   }
   47124           0 :   arg2 = (char *)(buf2);
   47125             :   {
   47126           0 :     if (arg1->httpcookiedata) free((char*)arg1->httpcookiedata);
   47127           0 :     if (arg2) {
   47128           0 :       arg1->httpcookiedata = (char *) malloc(strlen(arg2)+1);
   47129             :       strcpy((char*)arg1->httpcookiedata,arg2);
   47130             :     } else {
   47131           0 :       arg1->httpcookiedata = 0;
   47132             :     }
   47133             :   }
   47134             :   resultobj = SWIG_Py_Void();
   47135           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47136             :   return resultobj;
   47137           0 : fail:
   47138           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47139             :   return NULL;
   47140             : }
   47141             : 
   47142             : 
   47143           0 : SWIGINTERN PyObject *_wrap_OWSRequest_httpcookiedata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47144             :   PyObject *resultobj = 0;
   47145             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47146           0 :   void *argp1 = 0 ;
   47147             :   int res1 = 0 ;
   47148           0 :   PyObject * obj0 = 0 ;
   47149             :   char *result = 0 ;
   47150             :   
   47151           0 :   if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_httpcookiedata_get",&obj0)) SWIG_fail;
   47152           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47153           0 :   if (!SWIG_IsOK(res1)) {
   47154           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_httpcookiedata_get" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47155             :   }
   47156           0 :   arg1 = (cgiRequestObj *)(argp1);
   47157           0 :   result = (char *) ((arg1)->httpcookiedata);
   47158           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47159           0 :   return resultobj;
   47160           0 : fail:
   47161             :   return NULL;
   47162             : }
   47163             : 
   47164             : 
   47165           1 : SWIGINTERN PyObject *_wrap_new_OWSRequest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47166             :   PyObject *resultobj = 0;
   47167             :   cgiRequestObj *result = 0 ;
   47168             :   
   47169           1 :   if (!PyArg_ParseTuple(args,(char *)":new_OWSRequest")) SWIG_fail;
   47170             :   {
   47171           1 :     result = (cgiRequestObj *)new_cgiRequestObj(); {
   47172           1 :       errorObj *ms_error = msGetErrorObj();
   47173             :       
   47174           1 :       switch(ms_error->code) {
   47175             :       case MS_NOERR:
   47176             :         break;
   47177           0 :       case MS_NOTFOUND:
   47178           0 :         msResetErrorList();
   47179           0 :         break;
   47180             :       case -1:
   47181             :         break;
   47182           0 :       case MS_IOERR:
   47183           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47184           0 :           _raise_ms_exception();
   47185           0 :           msResetErrorList();
   47186           0 :           return NULL;
   47187             :         }
   47188             :       default:
   47189           0 :         _raise_ms_exception();
   47190           0 :         msResetErrorList();
   47191           0 :         return NULL;
   47192             :       }
   47193             :       
   47194             :     }
   47195             :   }
   47196           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cgiRequestObj, SWIG_POINTER_NEW |  0 );
   47197           1 :   return resultobj;
   47198           1 : fail:
   47199             :   return NULL;
   47200             : }
   47201             : 
   47202             : 
   47203           1 : SWIGINTERN PyObject *_wrap_delete_OWSRequest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47204             :   PyObject *resultobj = 0;
   47205             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47206           1 :   void *argp1 = 0 ;
   47207             :   int res1 = 0 ;
   47208           1 :   PyObject * obj0 = 0 ;
   47209             :   
   47210           1 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_OWSRequest",&obj0)) SWIG_fail;
   47211           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, SWIG_POINTER_DISOWN |  0 );
   47212           1 :   if (!SWIG_IsOK(res1)) {
   47213           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OWSRequest" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47214             :   }
   47215           1 :   arg1 = (cgiRequestObj *)(argp1);
   47216             :   {
   47217             :     delete_cgiRequestObj(arg1); {
   47218           1 :       errorObj *ms_error = msGetErrorObj();
   47219             :       
   47220           1 :       switch(ms_error->code) {
   47221             :       case MS_NOERR:
   47222             :         break;
   47223           0 :       case MS_NOTFOUND:
   47224           0 :         msResetErrorList();
   47225           0 :         break;
   47226             :       case -1:
   47227             :         break;
   47228           0 :       case MS_IOERR:
   47229           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47230           0 :           _raise_ms_exception();
   47231           0 :           msResetErrorList();
   47232           0 :           return NULL;
   47233             :         }
   47234             :       default:
   47235           0 :         _raise_ms_exception();
   47236           0 :         msResetErrorList();
   47237           0 :         return NULL;
   47238             :       }
   47239             :       
   47240             :     }
   47241             :   }
   47242             :   resultobj = SWIG_Py_Void();
   47243           1 :   return resultobj;
   47244           0 : fail:
   47245             :   return NULL;
   47246             : }
   47247             : 
   47248             : 
   47249           0 : SWIGINTERN PyObject *_wrap_OWSRequest_loadParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47250             :   PyObject *resultobj = 0;
   47251             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47252           0 :   void *argp1 = 0 ;
   47253             :   int res1 = 0 ;
   47254           0 :   PyObject * obj0 = 0 ;
   47255             :   int result;
   47256             :   
   47257           0 :   if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_loadParams",&obj0)) SWIG_fail;
   47258           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47259           0 :   if (!SWIG_IsOK(res1)) {
   47260           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_loadParams" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47261             :   }
   47262           0 :   arg1 = (cgiRequestObj *)(argp1);
   47263             :   {
   47264             :     result = (int)cgiRequestObj_loadParams(arg1); {
   47265           0 :       errorObj *ms_error = msGetErrorObj();
   47266             :       
   47267           0 :       switch(ms_error->code) {
   47268             :       case MS_NOERR:
   47269             :         break;
   47270           0 :       case MS_NOTFOUND:
   47271           0 :         msResetErrorList();
   47272           0 :         break;
   47273             :       case -1:
   47274             :         break;
   47275           0 :       case MS_IOERR:
   47276           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47277           0 :           _raise_ms_exception();
   47278           0 :           msResetErrorList();
   47279           0 :           return NULL;
   47280             :         }
   47281             :       default:
   47282           0 :         _raise_ms_exception();
   47283           0 :         msResetErrorList();
   47284           0 :         return NULL;
   47285             :       }
   47286             :       
   47287             :     }
   47288             :   }
   47289             :   resultobj = SWIG_From_int((int)(result));
   47290           0 :   return resultobj;
   47291           0 : fail:
   47292             :   return NULL;
   47293             : }
   47294             : 
   47295             : 
   47296           1 : SWIGINTERN PyObject *_wrap_OWSRequest_loadParamsFromURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47297             :   PyObject *resultobj = 0;
   47298             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47299             :   char *arg2 = (char *) 0 ;
   47300           1 :   void *argp1 = 0 ;
   47301             :   int res1 = 0 ;
   47302             :   int res2 ;
   47303           1 :   char *buf2 = 0 ;
   47304           1 :   int alloc2 = 0 ;
   47305           1 :   PyObject * obj0 = 0 ;
   47306           1 :   PyObject * obj1 = 0 ;
   47307             :   int result;
   47308             :   
   47309           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_loadParamsFromURL",&obj0,&obj1)) SWIG_fail;
   47310           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47311           1 :   if (!SWIG_IsOK(res1)) {
   47312           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_loadParamsFromURL" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47313             :   }
   47314           1 :   arg1 = (cgiRequestObj *)(argp1);
   47315           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   47316           1 :   if (!SWIG_IsOK(res2)) {
   47317           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_loadParamsFromURL" "', argument " "2"" of type '" "char const *""'");
   47318             :   }
   47319           1 :   arg2 = (char *)(buf2);
   47320             :   {
   47321             :     result = (int)cgiRequestObj_loadParamsFromURL(arg1,(char const *)arg2); {
   47322           1 :       errorObj *ms_error = msGetErrorObj();
   47323             :       
   47324           1 :       switch(ms_error->code) {
   47325             :       case MS_NOERR:
   47326             :         break;
   47327           0 :       case MS_NOTFOUND:
   47328           0 :         msResetErrorList();
   47329           0 :         break;
   47330             :       case -1:
   47331             :         break;
   47332           0 :       case MS_IOERR:
   47333           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47334           0 :           _raise_ms_exception();
   47335           0 :           msResetErrorList();
   47336           0 :           return NULL;
   47337             :         }
   47338             :       default:
   47339           0 :         _raise_ms_exception();
   47340           0 :         msResetErrorList();
   47341           0 :         return NULL;
   47342             :       }
   47343             :       
   47344             :     }
   47345             :   }
   47346             :   resultobj = SWIG_From_int((int)(result));
   47347           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47348             :   return resultobj;
   47349           0 : fail:
   47350           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47351             :   return NULL;
   47352             : }
   47353             : 
   47354             : 
   47355           1 : SWIGINTERN PyObject *_wrap_OWSRequest_setParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47356             :   PyObject *resultobj = 0;
   47357             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47358             :   char *arg2 = (char *) 0 ;
   47359             :   char *arg3 = (char *) 0 ;
   47360           1 :   void *argp1 = 0 ;
   47361             :   int res1 = 0 ;
   47362             :   int res2 ;
   47363           1 :   char *buf2 = 0 ;
   47364           1 :   int alloc2 = 0 ;
   47365             :   int res3 ;
   47366           1 :   char *buf3 = 0 ;
   47367           1 :   int alloc3 = 0 ;
   47368           1 :   PyObject * obj0 = 0 ;
   47369           1 :   PyObject * obj1 = 0 ;
   47370           1 :   PyObject * obj2 = 0 ;
   47371             :   
   47372           1 :   if (!PyArg_ParseTuple(args,(char *)"OOO:OWSRequest_setParameter",&obj0,&obj1,&obj2)) SWIG_fail;
   47373           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47374           1 :   if (!SWIG_IsOK(res1)) {
   47375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_setParameter" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47376             :   }
   47377           1 :   arg1 = (cgiRequestObj *)(argp1);
   47378           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   47379           1 :   if (!SWIG_IsOK(res2)) {
   47380           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_setParameter" "', argument " "2"" of type '" "char *""'");
   47381             :   }
   47382           1 :   arg2 = (char *)(buf2);
   47383           1 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   47384           1 :   if (!SWIG_IsOK(res3)) {
   47385           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OWSRequest_setParameter" "', argument " "3"" of type '" "char *""'");
   47386             :   }
   47387           1 :   arg3 = (char *)(buf3);
   47388             :   {
   47389           1 :     cgiRequestObj_setParameter(arg1,arg2,arg3); {
   47390           1 :       errorObj *ms_error = msGetErrorObj();
   47391             :       
   47392           1 :       switch(ms_error->code) {
   47393             :       case MS_NOERR:
   47394             :         break;
   47395           0 :       case MS_NOTFOUND:
   47396           0 :         msResetErrorList();
   47397           0 :         break;
   47398             :       case -1:
   47399             :         break;
   47400           0 :       case MS_IOERR:
   47401           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47402           0 :           _raise_ms_exception();
   47403           0 :           msResetErrorList();
   47404           0 :           return NULL;
   47405             :         }
   47406             :       default:
   47407           0 :         _raise_ms_exception();
   47408           0 :         msResetErrorList();
   47409           0 :         return NULL;
   47410             :       }
   47411             :       
   47412             :     }
   47413             :   }
   47414             :   resultobj = SWIG_Py_Void();
   47415           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47416           1 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   47417             :   return resultobj;
   47418           0 : fail:
   47419           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47420           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   47421             :   return NULL;
   47422             : }
   47423             : 
   47424             : 
   47425           0 : SWIGINTERN PyObject *_wrap_OWSRequest_addParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47426             :   PyObject *resultobj = 0;
   47427             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47428             :   char *arg2 = (char *) 0 ;
   47429             :   char *arg3 = (char *) 0 ;
   47430           0 :   void *argp1 = 0 ;
   47431             :   int res1 = 0 ;
   47432             :   int res2 ;
   47433           0 :   char *buf2 = 0 ;
   47434           0 :   int alloc2 = 0 ;
   47435             :   int res3 ;
   47436           0 :   char *buf3 = 0 ;
   47437           0 :   int alloc3 = 0 ;
   47438           0 :   PyObject * obj0 = 0 ;
   47439           0 :   PyObject * obj1 = 0 ;
   47440           0 :   PyObject * obj2 = 0 ;
   47441             :   
   47442           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:OWSRequest_addParameter",&obj0,&obj1,&obj2)) SWIG_fail;
   47443           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47444           0 :   if (!SWIG_IsOK(res1)) {
   47445           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_addParameter" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47446             :   }
   47447           0 :   arg1 = (cgiRequestObj *)(argp1);
   47448           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   47449           0 :   if (!SWIG_IsOK(res2)) {
   47450           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_addParameter" "', argument " "2"" of type '" "char *""'");
   47451             :   }
   47452           0 :   arg2 = (char *)(buf2);
   47453           0 :   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
   47454           0 :   if (!SWIG_IsOK(res3)) {
   47455           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OWSRequest_addParameter" "', argument " "3"" of type '" "char *""'");
   47456             :   }
   47457           0 :   arg3 = (char *)(buf3);
   47458             :   {
   47459           0 :     cgiRequestObj_addParameter(arg1,arg2,arg3); {
   47460           0 :       errorObj *ms_error = msGetErrorObj();
   47461             :       
   47462           0 :       switch(ms_error->code) {
   47463             :       case MS_NOERR:
   47464             :         break;
   47465           0 :       case MS_NOTFOUND:
   47466           0 :         msResetErrorList();
   47467           0 :         break;
   47468             :       case -1:
   47469             :         break;
   47470           0 :       case MS_IOERR:
   47471           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47472           0 :           _raise_ms_exception();
   47473           0 :           msResetErrorList();
   47474           0 :           return NULL;
   47475             :         }
   47476             :       default:
   47477           0 :         _raise_ms_exception();
   47478           0 :         msResetErrorList();
   47479           0 :         return NULL;
   47480             :       }
   47481             :       
   47482             :     }
   47483             :   }
   47484             :   resultobj = SWIG_Py_Void();
   47485           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47486           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   47487             :   return resultobj;
   47488           0 : fail:
   47489           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47490           0 :   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   47491             :   return NULL;
   47492             : }
   47493             : 
   47494             : 
   47495           1 : SWIGINTERN PyObject *_wrap_OWSRequest_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47496             :   PyObject *resultobj = 0;
   47497             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47498             :   int arg2 ;
   47499           1 :   void *argp1 = 0 ;
   47500             :   int res1 = 0 ;
   47501             :   int val2 ;
   47502             :   int ecode2 = 0 ;
   47503           1 :   PyObject * obj0 = 0 ;
   47504           1 :   PyObject * obj1 = 0 ;
   47505             :   char *result = 0 ;
   47506             :   
   47507           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_getName",&obj0,&obj1)) SWIG_fail;
   47508           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47509           1 :   if (!SWIG_IsOK(res1)) {
   47510           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_getName" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47511             :   }
   47512           1 :   arg1 = (cgiRequestObj *)(argp1);
   47513           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   47514           1 :   if (!SWIG_IsOK(ecode2)) {
   47515           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OWSRequest_getName" "', argument " "2"" of type '" "int""'");
   47516             :   } 
   47517             :   arg2 = (int)(val2);
   47518             :   {
   47519           1 :     result = (char *)cgiRequestObj_getName(arg1,arg2); {
   47520           1 :       errorObj *ms_error = msGetErrorObj();
   47521             :       
   47522           1 :       switch(ms_error->code) {
   47523             :       case MS_NOERR:
   47524             :         break;
   47525           0 :       case MS_NOTFOUND:
   47526           0 :         msResetErrorList();
   47527           0 :         break;
   47528             :       case -1:
   47529             :         break;
   47530           0 :       case MS_IOERR:
   47531           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47532           0 :           _raise_ms_exception();
   47533           0 :           msResetErrorList();
   47534           0 :           return NULL;
   47535             :         }
   47536             :       default:
   47537           0 :         _raise_ms_exception();
   47538           0 :         msResetErrorList();
   47539           0 :         return NULL;
   47540             :       }
   47541             :       
   47542             :     }
   47543             :   }
   47544           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47545           1 :   return resultobj;
   47546           0 : fail:
   47547             :   return NULL;
   47548             : }
   47549             : 
   47550             : 
   47551           1 : SWIGINTERN PyObject *_wrap_OWSRequest_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47552             :   PyObject *resultobj = 0;
   47553             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47554             :   int arg2 ;
   47555           1 :   void *argp1 = 0 ;
   47556             :   int res1 = 0 ;
   47557             :   int val2 ;
   47558             :   int ecode2 = 0 ;
   47559           1 :   PyObject * obj0 = 0 ;
   47560           1 :   PyObject * obj1 = 0 ;
   47561             :   char *result = 0 ;
   47562             :   
   47563           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_getValue",&obj0,&obj1)) SWIG_fail;
   47564           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47565           1 :   if (!SWIG_IsOK(res1)) {
   47566           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_getValue" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47567             :   }
   47568           1 :   arg1 = (cgiRequestObj *)(argp1);
   47569           1 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
   47570           1 :   if (!SWIG_IsOK(ecode2)) {
   47571           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OWSRequest_getValue" "', argument " "2"" of type '" "int""'");
   47572             :   } 
   47573             :   arg2 = (int)(val2);
   47574             :   {
   47575           1 :     result = (char *)cgiRequestObj_getValue(arg1,arg2); {
   47576           1 :       errorObj *ms_error = msGetErrorObj();
   47577             :       
   47578           1 :       switch(ms_error->code) {
   47579             :       case MS_NOERR:
   47580             :         break;
   47581           0 :       case MS_NOTFOUND:
   47582           0 :         msResetErrorList();
   47583           0 :         break;
   47584             :       case -1:
   47585             :         break;
   47586           0 :       case MS_IOERR:
   47587           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47588           0 :           _raise_ms_exception();
   47589           0 :           msResetErrorList();
   47590           0 :           return NULL;
   47591             :         }
   47592             :       default:
   47593           0 :         _raise_ms_exception();
   47594           0 :         msResetErrorList();
   47595           0 :         return NULL;
   47596             :       }
   47597             :       
   47598             :     }
   47599             :   }
   47600           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47601           1 :   return resultobj;
   47602           0 : fail:
   47603             :   return NULL;
   47604             : }
   47605             : 
   47606             : 
   47607           1 : SWIGINTERN PyObject *_wrap_OWSRequest_getValueByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47608             :   PyObject *resultobj = 0;
   47609             :   cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
   47610             :   char *arg2 = (char *) 0 ;
   47611           1 :   void *argp1 = 0 ;
   47612             :   int res1 = 0 ;
   47613             :   int res2 ;
   47614           1 :   char *buf2 = 0 ;
   47615           1 :   int alloc2 = 0 ;
   47616           1 :   PyObject * obj0 = 0 ;
   47617           1 :   PyObject * obj1 = 0 ;
   47618             :   char *result = 0 ;
   47619             :   
   47620           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_getValueByName",&obj0,&obj1)) SWIG_fail;
   47621           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 |  0 );
   47622           1 :   if (!SWIG_IsOK(res1)) {
   47623           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_getValueByName" "', argument " "1"" of type '" "cgiRequestObj *""'"); 
   47624             :   }
   47625           1 :   arg1 = (cgiRequestObj *)(argp1);
   47626           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   47627           1 :   if (!SWIG_IsOK(res2)) {
   47628           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_getValueByName" "', argument " "2"" of type '" "char const *""'");
   47629             :   }
   47630           1 :   arg2 = (char *)(buf2);
   47631             :   {
   47632           1 :     result = (char *)cgiRequestObj_getValueByName(arg1,(char const *)arg2); {
   47633           1 :       errorObj *ms_error = msGetErrorObj();
   47634             :       
   47635           1 :       switch(ms_error->code) {
   47636             :       case MS_NOERR:
   47637             :         break;
   47638           0 :       case MS_NOTFOUND:
   47639           0 :         msResetErrorList();
   47640           0 :         break;
   47641             :       case -1:
   47642             :         break;
   47643           0 :       case MS_IOERR:
   47644           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47645           0 :           _raise_ms_exception();
   47646           0 :           msResetErrorList();
   47647           0 :           return NULL;
   47648             :         }
   47649             :       default:
   47650           0 :         _raise_ms_exception();
   47651           0 :         msResetErrorList();
   47652           0 :         return NULL;
   47653             :       }
   47654             :       
   47655             :     }
   47656             :   }
   47657           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47658           1 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47659             :   return resultobj;
   47660           0 : fail:
   47661           0 :   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   47662             :   return NULL;
   47663             : }
   47664             : 
   47665             : 
   47666           1 : SWIGINTERN PyObject *OWSRequest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47667             :   PyObject *obj;
   47668           1 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
   47669           1 :   SWIG_TypeNewClientData(SWIGTYPE_p_cgiRequestObj, SWIG_NewClientData(obj));
   47670           1 :   return SWIG_Py_Void();
   47671             : }
   47672             : 
   47673           0 : SWIGINTERN PyObject *_wrap_msConnPoolCloseUnreferenced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47674             :   PyObject *resultobj = 0;
   47675             :   
   47676           0 :   if (!PyArg_ParseTuple(args,(char *)":msConnPoolCloseUnreferenced")) SWIG_fail;
   47677             :   {
   47678           0 :     msConnPoolCloseUnreferenced(); {
   47679           0 :       errorObj *ms_error = msGetErrorObj();
   47680             :       
   47681           0 :       switch(ms_error->code) {
   47682             :       case MS_NOERR:
   47683             :         break;
   47684           0 :       case MS_NOTFOUND:
   47685           0 :         msResetErrorList();
   47686           0 :         break;
   47687             :       case -1:
   47688             :         break;
   47689           0 :       case MS_IOERR:
   47690           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47691           0 :           _raise_ms_exception();
   47692           0 :           msResetErrorList();
   47693           0 :           return NULL;
   47694             :         }
   47695             :       default:
   47696           0 :         _raise_ms_exception();
   47697           0 :         msResetErrorList();
   47698           0 :         return NULL;
   47699             :       }
   47700             :       
   47701             :     }
   47702             :   }
   47703             :   resultobj = SWIG_Py_Void();
   47704           0 :   return resultobj;
   47705           0 : fail:
   47706             :   return NULL;
   47707             : }
   47708             : 
   47709             : 
   47710           0 : SWIGINTERN PyObject *_wrap_msIO_resetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47711             :   PyObject *resultobj = 0;
   47712             :   
   47713           0 :   if (!PyArg_ParseTuple(args,(char *)":msIO_resetHandlers")) SWIG_fail;
   47714             :   {
   47715           0 :     msIO_resetHandlers(); {
   47716           0 :       errorObj *ms_error = msGetErrorObj();
   47717             :       
   47718           0 :       switch(ms_error->code) {
   47719             :       case MS_NOERR:
   47720             :         break;
   47721           0 :       case MS_NOTFOUND:
   47722           0 :         msResetErrorList();
   47723           0 :         break;
   47724             :       case -1:
   47725             :         break;
   47726           0 :       case MS_IOERR:
   47727           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47728           0 :           _raise_ms_exception();
   47729           0 :           msResetErrorList();
   47730           0 :           return NULL;
   47731             :         }
   47732             :       default:
   47733           0 :         _raise_ms_exception();
   47734           0 :         msResetErrorList();
   47735           0 :         return NULL;
   47736             :       }
   47737             :       
   47738             :     }
   47739             :   }
   47740             :   resultobj = SWIG_Py_Void();
   47741           0 :   return resultobj;
   47742           0 : fail:
   47743             :   return NULL;
   47744             : }
   47745             : 
   47746             : 
   47747           1 : SWIGINTERN PyObject *_wrap_msIO_installStdoutToBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47748             :   PyObject *resultobj = 0;
   47749             :   
   47750           1 :   if (!PyArg_ParseTuple(args,(char *)":msIO_installStdoutToBuffer")) SWIG_fail;
   47751             :   {
   47752           1 :     msIO_installStdoutToBuffer(); {
   47753           1 :       errorObj *ms_error = msGetErrorObj();
   47754             :       
   47755           1 :       switch(ms_error->code) {
   47756             :       case MS_NOERR:
   47757             :         break;
   47758           0 :       case MS_NOTFOUND:
   47759           0 :         msResetErrorList();
   47760           0 :         break;
   47761             :       case -1:
   47762             :         break;
   47763           0 :       case MS_IOERR:
   47764           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47765           0 :           _raise_ms_exception();
   47766           0 :           msResetErrorList();
   47767           0 :           return NULL;
   47768             :         }
   47769             :       default:
   47770           0 :         _raise_ms_exception();
   47771           0 :         msResetErrorList();
   47772           0 :         return NULL;
   47773             :       }
   47774             :       
   47775             :     }
   47776             :   }
   47777             :   resultobj = SWIG_Py_Void();
   47778           1 :   return resultobj;
   47779           1 : fail:
   47780             :   return NULL;
   47781             : }
   47782             : 
   47783             : 
   47784           0 : SWIGINTERN PyObject *_wrap_msIO_installStdinFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47785             :   PyObject *resultobj = 0;
   47786             :   
   47787           0 :   if (!PyArg_ParseTuple(args,(char *)":msIO_installStdinFromBuffer")) SWIG_fail;
   47788             :   {
   47789           0 :     msIO_installStdinFromBuffer(); {
   47790           0 :       errorObj *ms_error = msGetErrorObj();
   47791             :       
   47792           0 :       switch(ms_error->code) {
   47793             :       case MS_NOERR:
   47794             :         break;
   47795           0 :       case MS_NOTFOUND:
   47796           0 :         msResetErrorList();
   47797           0 :         break;
   47798             :       case -1:
   47799             :         break;
   47800           0 :       case MS_IOERR:
   47801           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47802           0 :           _raise_ms_exception();
   47803           0 :           msResetErrorList();
   47804           0 :           return NULL;
   47805             :         }
   47806             :       default:
   47807           0 :         _raise_ms_exception();
   47808           0 :         msResetErrorList();
   47809           0 :         return NULL;
   47810             :       }
   47811             :       
   47812             :     }
   47813             :   }
   47814             :   resultobj = SWIG_Py_Void();
   47815           0 :   return resultobj;
   47816           0 : fail:
   47817             :   return NULL;
   47818             : }
   47819             : 
   47820             : 
   47821           1 : SWIGINTERN PyObject *_wrap_msIO_stripStdoutBufferContentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47822             :   PyObject *resultobj = 0;
   47823             :   char *result = 0 ;
   47824             :   
   47825           1 :   if (!PyArg_ParseTuple(args,(char *)":msIO_stripStdoutBufferContentType")) SWIG_fail;
   47826             :   {
   47827           1 :     result = (char *)msIO_stripStdoutBufferContentType(); {
   47828           1 :       errorObj *ms_error = msGetErrorObj();
   47829             :       
   47830           1 :       switch(ms_error->code) {
   47831             :       case MS_NOERR:
   47832             :         break;
   47833           0 :       case MS_NOTFOUND:
   47834           0 :         msResetErrorList();
   47835           0 :         break;
   47836             :       case -1:
   47837             :         break;
   47838           0 :       case MS_IOERR:
   47839           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47840           0 :           _raise_ms_exception();
   47841           0 :           msResetErrorList();
   47842           0 :           return NULL;
   47843             :         }
   47844             :       default:
   47845           0 :         _raise_ms_exception();
   47846           0 :         msResetErrorList();
   47847           0 :         return NULL;
   47848             :       }
   47849             :       
   47850             :     }
   47851             :   }
   47852           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47853           1 :   free((char*)result);
   47854           1 :   return resultobj;
   47855           1 : fail:
   47856             :   return NULL;
   47857             : }
   47858             : 
   47859             : 
   47860           1 : SWIGINTERN PyObject *_wrap_msIO_stripStdoutBufferContentHeaders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47861             :   PyObject *resultobj = 0;
   47862             :   
   47863           1 :   if (!PyArg_ParseTuple(args,(char *)":msIO_stripStdoutBufferContentHeaders")) SWIG_fail;
   47864             :   {
   47865           1 :     msIO_stripStdoutBufferContentHeaders(); {
   47866           1 :       errorObj *ms_error = msGetErrorObj();
   47867             :       
   47868           1 :       switch(ms_error->code) {
   47869             :       case MS_NOERR:
   47870             :         break;
   47871           0 :       case MS_NOTFOUND:
   47872           0 :         msResetErrorList();
   47873           0 :         break;
   47874             :       case -1:
   47875             :         break;
   47876           0 :       case MS_IOERR:
   47877           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47878           0 :           _raise_ms_exception();
   47879           0 :           msResetErrorList();
   47880           0 :           return NULL;
   47881             :         }
   47882             :       default:
   47883           0 :         _raise_ms_exception();
   47884           0 :         msResetErrorList();
   47885           0 :         return NULL;
   47886             :       }
   47887             :       
   47888             :     }
   47889             :   }
   47890             :   resultobj = SWIG_Py_Void();
   47891           1 :   return resultobj;
   47892           1 : fail:
   47893             :   return NULL;
   47894             : }
   47895             : 
   47896             : 
   47897           0 : SWIGINTERN PyObject *_wrap_msIO_getStdoutBufferString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47898             :   PyObject *resultobj = 0;
   47899             :   char *result = 0 ;
   47900             :   
   47901           0 :   if (!PyArg_ParseTuple(args,(char *)":msIO_getStdoutBufferString")) SWIG_fail;
   47902             :   {
   47903           0 :     result = (char *)msIO_getStdoutBufferString(); {
   47904           0 :       errorObj *ms_error = msGetErrorObj();
   47905             :       
   47906           0 :       switch(ms_error->code) {
   47907             :       case MS_NOERR:
   47908             :         break;
   47909           0 :       case MS_NOTFOUND:
   47910           0 :         msResetErrorList();
   47911           0 :         break;
   47912             :       case -1:
   47913             :         break;
   47914           0 :       case MS_IOERR:
   47915           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47916           0 :           _raise_ms_exception();
   47917           0 :           msResetErrorList();
   47918           0 :           return NULL;
   47919             :         }
   47920             :       default:
   47921           0 :         _raise_ms_exception();
   47922           0 :         msResetErrorList();
   47923           0 :         return NULL;
   47924             :       }
   47925             :       
   47926             :     }
   47927             :   }
   47928           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
   47929           0 :   return resultobj;
   47930           0 : fail:
   47931             :   return NULL;
   47932             : }
   47933             : 
   47934             : 
   47935           1 : SWIGINTERN PyObject *_wrap_msIO_getStdoutBufferBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47936             :   PyObject *resultobj = 0;
   47937             :   gdBuffer result;
   47938             :   
   47939           1 :   if (!PyArg_ParseTuple(args,(char *)":msIO_getStdoutBufferBytes")) SWIG_fail;
   47940             :   {
   47941           1 :     result = msIO_getStdoutBufferBytes(); {
   47942           1 :       errorObj *ms_error = msGetErrorObj();
   47943             :       
   47944           1 :       switch(ms_error->code) {
   47945             :       case MS_NOERR:
   47946             :         break;
   47947           0 :       case MS_NOTFOUND:
   47948           0 :         msResetErrorList();
   47949           0 :         break;
   47950             :       case -1:
   47951             :         break;
   47952           0 :       case MS_IOERR:
   47953           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47954           0 :           _raise_ms_exception();
   47955           0 :           msResetErrorList();
   47956           0 :           return NULL;
   47957             :         }
   47958             :       default:
   47959           0 :         _raise_ms_exception();
   47960           0 :         msResetErrorList();
   47961           0 :         return NULL;
   47962             :       }
   47963             :       
   47964             :     }
   47965             :   }
   47966             :   {
   47967           1 :     resultobj = PyBytes_FromStringAndSize((const char*)(&result)->data, (&result)->size);
   47968           1 :     if( (&result)->owns_data )
   47969           1 :     msFree((&result)->data);
   47970             :   }
   47971             :   return resultobj;
   47972           1 : fail:
   47973             :   return NULL;
   47974             : }
   47975             : 
   47976             : 
   47977           1 : SWIGINTERN PyObject *_wrap_msIO_getAndStripStdoutBufferMimeHeaders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   47978             :   PyObject *resultobj = 0;
   47979             :   hashTableObj *result = 0 ;
   47980             :   
   47981           1 :   if (!PyArg_ParseTuple(args,(char *)":msIO_getAndStripStdoutBufferMimeHeaders")) SWIG_fail;
   47982             :   {
   47983           1 :     result = (hashTableObj *)msIO_getAndStripStdoutBufferMimeHeaders(); {
   47984           1 :       errorObj *ms_error = msGetErrorObj();
   47985             :       
   47986           1 :       switch(ms_error->code) {
   47987             :       case MS_NOERR:
   47988             :         break;
   47989           0 :       case MS_NOTFOUND:
   47990           0 :         msResetErrorList();
   47991           0 :         break;
   47992             :       case -1:
   47993             :         break;
   47994           0 :       case MS_IOERR:
   47995           0 :         if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
   47996           0 :           _raise_ms_exception();
   47997           0 :           msResetErrorList();
   47998           0 :           return NULL;
   47999             :         }
   48000             :       default:
   48001           0 :         _raise_ms_exception();
   48002           0 :         msResetErrorList();
   48003           0 :         return NULL;
   48004             :       }
   48005             :       
   48006             :     }
   48007             :   }
   48008           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, SWIG_POINTER_OWN |  0 );
   48009           1 :   return resultobj;
   48010           1 : fail:
   48011             :   return NULL;
   48012             : }
   48013             : 
   48014             : 
   48015             : static PyMethodDef SwigMethods[] = {
   48016             :    { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
   48017             :    { (char *)"new_intarray", _wrap_new_intarray, METH_VARARGS, NULL},
   48018             :    { (char *)"delete_intarray", _wrap_delete_intarray, METH_VARARGS, NULL},
   48019             :    { (char *)"intarray___getitem__", _wrap_intarray___getitem__, METH_VARARGS, NULL},
   48020             :    { (char *)"intarray___setitem__", _wrap_intarray___setitem__, METH_VARARGS, NULL},
   48021             :    { (char *)"intarray_cast", _wrap_intarray_cast, METH_VARARGS, NULL},
   48022             :    { (char *)"intarray_frompointer", _wrap_intarray_frompointer, METH_VARARGS, NULL},
   48023             :    { (char *)"intarray_swigregister", intarray_swigregister, METH_VARARGS, NULL},
   48024             :    { (char *)"CompositingFilter_filter_set", _wrap_CompositingFilter_filter_set, METH_VARARGS, NULL},
   48025             :    { (char *)"CompositingFilter_filter_get", _wrap_CompositingFilter_filter_get, METH_VARARGS, NULL},
   48026             :    { (char *)"CompositingFilter_next_set", _wrap_CompositingFilter_next_set, METH_VARARGS, NULL},
   48027             :    { (char *)"CompositingFilter_next_get", _wrap_CompositingFilter_next_get, METH_VARARGS, NULL},
   48028             :    { (char *)"new_CompositingFilter", _wrap_new_CompositingFilter, METH_VARARGS, NULL},
   48029             :    { (char *)"delete_CompositingFilter", _wrap_delete_CompositingFilter, METH_VARARGS, NULL},
   48030             :    { (char *)"CompositingFilter_swigregister", CompositingFilter_swigregister, METH_VARARGS, NULL},
   48031             :    { (char *)"LayerCompositer_comp_op_set", _wrap_LayerCompositer_comp_op_set, METH_VARARGS, NULL},
   48032             :    { (char *)"LayerCompositer_comp_op_get", _wrap_LayerCompositer_comp_op_get, METH_VARARGS, NULL},
   48033             :    { (char *)"LayerCompositer_opacity_set", _wrap_LayerCompositer_opacity_set, METH_VARARGS, NULL},
   48034             :    { (char *)"LayerCompositer_opacity_get", _wrap_LayerCompositer_opacity_get, METH_VARARGS, NULL},
   48035             :    { (char *)"LayerCompositer_filter_set", _wrap_LayerCompositer_filter_set, METH_VARARGS, NULL},
   48036             :    { (char *)"LayerCompositer_filter_get", _wrap_LayerCompositer_filter_get, METH_VARARGS, NULL},
   48037             :    { (char *)"LayerCompositer_next_set", _wrap_LayerCompositer_next_set, METH_VARARGS, NULL},
   48038             :    { (char *)"LayerCompositer_next_get", _wrap_LayerCompositer_next_get, METH_VARARGS, NULL},
   48039             :    { (char *)"new_LayerCompositer", _wrap_new_LayerCompositer, METH_VARARGS, NULL},
   48040             :    { (char *)"delete_LayerCompositer", _wrap_delete_LayerCompositer, METH_VARARGS, NULL},
   48041             :    { (char *)"LayerCompositer_swigregister", LayerCompositer_swigregister, METH_VARARGS, NULL},
   48042             :    { (char *)"fontSetObj_filename_get", _wrap_fontSetObj_filename_get, METH_VARARGS, NULL},
   48043             :    { (char *)"fontSetObj_numfonts_get", _wrap_fontSetObj_numfonts_get, METH_VARARGS, NULL},
   48044             :    { (char *)"fontSetObj_fonts_get", _wrap_fontSetObj_fonts_get, METH_VARARGS, NULL},
   48045             :    { (char *)"new_fontSetObj", _wrap_new_fontSetObj, METH_VARARGS, NULL},
   48046             :    { (char *)"delete_fontSetObj", _wrap_delete_fontSetObj, METH_VARARGS, NULL},
   48047             :    { (char *)"fontSetObj_swigregister", fontSetObj_swigregister, METH_VARARGS, NULL},
   48048             :    { (char *)"clusterObj_maxdistance_set", _wrap_clusterObj_maxdistance_set, METH_VARARGS, NULL},
   48049             :    { (char *)"clusterObj_maxdistance_get", _wrap_clusterObj_maxdistance_get, METH_VARARGS, NULL},
   48050             :    { (char *)"clusterObj_buffer_set", _wrap_clusterObj_buffer_set, METH_VARARGS, NULL},
   48051             :    { (char *)"clusterObj_buffer_get", _wrap_clusterObj_buffer_get, METH_VARARGS, NULL},
   48052             :    { (char *)"clusterObj_region_set", _wrap_clusterObj_region_set, METH_VARARGS, NULL},
   48053             :    { (char *)"clusterObj_region_get", _wrap_clusterObj_region_get, METH_VARARGS, NULL},
   48054             :    { (char *)"clusterObj_updateFromString", _wrap_clusterObj_updateFromString, METH_VARARGS, NULL},
   48055             :    { (char *)"clusterObj_convertToString", _wrap_clusterObj_convertToString, METH_VARARGS, NULL},
   48056             :    { (char *)"clusterObj_setGroup", _wrap_clusterObj_setGroup, METH_VARARGS, NULL},
   48057             :    { (char *)"clusterObj_getGroupString", _wrap_clusterObj_getGroupString, METH_VARARGS, NULL},
   48058             :    { (char *)"clusterObj_setFilter", _wrap_clusterObj_setFilter, METH_VARARGS, NULL},
   48059             :    { (char *)"clusterObj_getFilterString", _wrap_clusterObj_getFilterString, METH_VARARGS, NULL},
   48060             :    { (char *)"new_clusterObj", _wrap_new_clusterObj, METH_VARARGS, NULL},
   48061             :    { (char *)"delete_clusterObj", _wrap_delete_clusterObj, METH_VARARGS, NULL},
   48062             :    { (char *)"clusterObj_swigregister", clusterObj_swigregister, METH_VARARGS, NULL},
   48063             :    { (char *)"outputFormatObj_numformatoptions_get", _wrap_outputFormatObj_numformatoptions_get, METH_VARARGS, NULL},
   48064             :    { (char *)"outputFormatObj_name_set", _wrap_outputFormatObj_name_set, METH_VARARGS, NULL},
   48065             :    { (char *)"outputFormatObj_name_get", _wrap_outputFormatObj_name_get, METH_VARARGS, NULL},
   48066             :    { (char *)"outputFormatObj_mimetype_set", _wrap_outputFormatObj_mimetype_set, METH_VARARGS, NULL},
   48067             :    { (char *)"outputFormatObj_mimetype_get", _wrap_outputFormatObj_mimetype_get, METH_VARARGS, NULL},
   48068             :    { (char *)"outputFormatObj_driver_set", _wrap_outputFormatObj_driver_set, METH_VARARGS, NULL},
   48069             :    { (char *)"outputFormatObj_driver_get", _wrap_outputFormatObj_driver_get, METH_VARARGS, NULL},
   48070             :    { (char *)"outputFormatObj_extension_set", _wrap_outputFormatObj_extension_set, METH_VARARGS, NULL},
   48071             :    { (char *)"outputFormatObj_extension_get", _wrap_outputFormatObj_extension_get, METH_VARARGS, NULL},
   48072             :    { (char *)"outputFormatObj_renderer_set", _wrap_outputFormatObj_renderer_set, METH_VARARGS, NULL},
   48073             :    { (char *)"outputFormatObj_renderer_get", _wrap_outputFormatObj_renderer_get, METH_VARARGS, NULL},
   48074             :    { (char *)"outputFormatObj_imagemode_set", _wrap_outputFormatObj_imagemode_set, METH_VARARGS, NULL},
   48075             :    { (char *)"outputFormatObj_imagemode_get", _wrap_outputFormatObj_imagemode_get, METH_VARARGS, NULL},
   48076             :    { (char *)"outputFormatObj_transparent_set", _wrap_outputFormatObj_transparent_set, METH_VARARGS, NULL},
   48077             :    { (char *)"outputFormatObj_transparent_get", _wrap_outputFormatObj_transparent_get, METH_VARARGS, NULL},
   48078             :    { (char *)"outputFormatObj_bands_set", _wrap_outputFormatObj_bands_set, METH_VARARGS, NULL},
   48079             :    { (char *)"outputFormatObj_bands_get", _wrap_outputFormatObj_bands_get, METH_VARARGS, NULL},
   48080             :    { (char *)"outputFormatObj_inmapfile_set", _wrap_outputFormatObj_inmapfile_set, METH_VARARGS, NULL},
   48081             :    { (char *)"outputFormatObj_inmapfile_get", _wrap_outputFormatObj_inmapfile_get, METH_VARARGS, NULL},
   48082             :    { (char *)"new_outputFormatObj", _wrap_new_outputFormatObj, METH_VARARGS, NULL},
   48083             :    { (char *)"delete_outputFormatObj", _wrap_delete_outputFormatObj, METH_VARARGS, NULL},
   48084             :    { (char *)"outputFormatObj_setExtension", _wrap_outputFormatObj_setExtension, METH_VARARGS, NULL},
   48085             :    { (char *)"outputFormatObj_setMimetype", _wrap_outputFormatObj_setMimetype, METH_VARARGS, NULL},
   48086             :    { (char *)"outputFormatObj_setOption", _wrap_outputFormatObj_setOption, METH_VARARGS, NULL},
   48087             :    { (char *)"outputFormatObj_validate", _wrap_outputFormatObj_validate, METH_VARARGS, NULL},
   48088             :    { (char *)"outputFormatObj_getOption", _wrap_outputFormatObj_getOption, METH_VARARGS, NULL},
   48089             :    { (char *)"outputFormatObj_getOptionAt", _wrap_outputFormatObj_getOptionAt, METH_VARARGS, NULL},
   48090             :    { (char *)"outputFormatObj_attachDevice", _wrap_outputFormatObj_attachDevice, METH_VARARGS, NULL},
   48091             :    { (char *)"outputFormatObj_swigregister", outputFormatObj_swigregister, METH_VARARGS, NULL},
   48092             :    { (char *)"queryMapObj_height_set", _wrap_queryMapObj_height_set, METH_VARARGS, NULL},
   48093             :    { (char *)"queryMapObj_height_get", _wrap_queryMapObj_height_get, METH_VARARGS, NULL},
   48094             :    { (char *)"queryMapObj_width_set", _wrap_queryMapObj_width_set, METH_VARARGS, NULL},
   48095             :    { (char *)"queryMapObj_width_get", _wrap_queryMapObj_width_get, METH_VARARGS, NULL},
   48096             :    { (char *)"queryMapObj_status_set", _wrap_queryMapObj_status_set, METH_VARARGS, NULL},
   48097             :    { (char *)"queryMapObj_status_get", _wrap_queryMapObj_status_get, METH_VARARGS, NULL},
   48098             :    { (char *)"queryMapObj_style_set", _wrap_queryMapObj_style_set, METH_VARARGS, NULL},
   48099             :    { (char *)"queryMapObj_style_get", _wrap_queryMapObj_style_get, METH_VARARGS, NULL},
   48100             :    { (char *)"queryMapObj_color_set", _wrap_queryMapObj_color_set, METH_VARARGS, NULL},
   48101             :    { (char *)"queryMapObj_color_get", _wrap_queryMapObj_color_get, METH_VARARGS, NULL},
   48102             :    { (char *)"queryMapObj_updateFromString", _wrap_queryMapObj_updateFromString, METH_VARARGS, NULL},
   48103             :    { (char *)"queryMapObj_convertToString", _wrap_queryMapObj_convertToString, METH_VARARGS, NULL},
   48104             :    { (char *)"new_queryMapObj", _wrap_new_queryMapObj, METH_VARARGS, NULL},
   48105             :    { (char *)"delete_queryMapObj", _wrap_delete_queryMapObj, METH_VARARGS, NULL},
   48106             :    { (char *)"queryMapObj_swigregister", queryMapObj_swigregister, METH_VARARGS, NULL},
   48107             :    { (char *)"webObj_log_set", _wrap_webObj_log_set, METH_VARARGS, NULL},
   48108             :    { (char *)"webObj_log_get", _wrap_webObj_log_get, METH_VARARGS, NULL},
   48109             :    { (char *)"webObj_imagepath_set", _wrap_webObj_imagepath_set, METH_VARARGS, NULL},
   48110             :    { (char *)"webObj_imagepath_get", _wrap_webObj_imagepath_get, METH_VARARGS, NULL},
   48111             :    { (char *)"webObj_imageurl_set", _wrap_webObj_imageurl_set, METH_VARARGS, NULL},
   48112             :    { (char *)"webObj_imageurl_get", _wrap_webObj_imageurl_get, METH_VARARGS, NULL},
   48113             :    { (char *)"webObj_temppath_set", _wrap_webObj_temppath_set, METH_VARARGS, NULL},
   48114             :    { (char *)"webObj_temppath_get", _wrap_webObj_temppath_get, METH_VARARGS, NULL},
   48115             :    { (char *)"webObj_map_get", _wrap_webObj_map_get, METH_VARARGS, NULL},
   48116             :    { (char *)"webObj_template_set", _wrap_webObj_template_set, METH_VARARGS, NULL},
   48117             :    { (char *)"webObj_template_get", _wrap_webObj_template_get, METH_VARARGS, NULL},
   48118             :    { (char *)"webObj_header_set", _wrap_webObj_header_set, METH_VARARGS, NULL},
   48119             :    { (char *)"webObj_header_get", _wrap_webObj_header_get, METH_VARARGS, NULL},
   48120             :    { (char *)"webObj_footer_set", _wrap_webObj_footer_set, METH_VARARGS, NULL},
   48121             :    { (char *)"webObj_footer_get", _wrap_webObj_footer_get, METH_VARARGS, NULL},
   48122             :    { (char *)"webObj_empty_set", _wrap_webObj_empty_set, METH_VARARGS, NULL},
   48123             :    { (char *)"webObj_empty_get", _wrap_webObj_empty_get, METH_VARARGS, NULL},
   48124             :    { (char *)"webObj_error_set", _wrap_webObj_error_set, METH_VARARGS, NULL},
   48125             :    { (char *)"webObj_error_get", _wrap_webObj_error_get, METH_VARARGS, NULL},
   48126             :    { (char *)"webObj_extent_set", _wrap_webObj_extent_set, METH_VARARGS, NULL},
   48127             :    { (char *)"webObj_extent_get", _wrap_webObj_extent_get, METH_VARARGS, NULL},
   48128             :    { (char *)"webObj_minscaledenom_set", _wrap_webObj_minscaledenom_set, METH_VARARGS, NULL},
   48129             :    { (char *)"webObj_minscaledenom_get", _wrap_webObj_minscaledenom_get, METH_VARARGS, NULL},
   48130             :    { (char *)"webObj_maxscaledenom_set", _wrap_webObj_maxscaledenom_set, METH_VARARGS, NULL},
   48131             :    { (char *)"webObj_maxscaledenom_get", _wrap_webObj_maxscaledenom_get, METH_VARARGS, NULL},
   48132             :    { (char *)"webObj_mintemplate_set", _wrap_webObj_mintemplate_set, METH_VARARGS, NULL},
   48133             :    { (char *)"webObj_mintemplate_get", _wrap_webObj_mintemplate_get, METH_VARARGS, NULL},
   48134             :    { (char *)"webObj_maxtemplate_set", _wrap_webObj_maxtemplate_set, METH_VARARGS, NULL},
   48135             :    { (char *)"webObj_maxtemplate_get", _wrap_webObj_maxtemplate_get, METH_VARARGS, NULL},
   48136             :    { (char *)"webObj_queryformat_set", _wrap_webObj_queryformat_set, METH_VARARGS, NULL},
   48137             :    { (char *)"webObj_queryformat_get", _wrap_webObj_queryformat_get, METH_VARARGS, NULL},
   48138             :    { (char *)"webObj_legendformat_set", _wrap_webObj_legendformat_set, METH_VARARGS, NULL},
   48139             :    { (char *)"webObj_legendformat_get", _wrap_webObj_legendformat_get, METH_VARARGS, NULL},
   48140             :    { (char *)"webObj_browseformat_set", _wrap_webObj_browseformat_set, METH_VARARGS, NULL},
   48141             :    { (char *)"webObj_browseformat_get", _wrap_webObj_browseformat_get, METH_VARARGS, NULL},
   48142             :    { (char *)"webObj_metadata_get", _wrap_webObj_metadata_get, METH_VARARGS, NULL},
   48143             :    { (char *)"webObj_validation_get", _wrap_webObj_validation_get, METH_VARARGS, NULL},
   48144             :    { (char *)"new_webObj", _wrap_new_webObj, METH_VARARGS, NULL},
   48145             :    { (char *)"delete_webObj", _wrap_delete_webObj, METH_VARARGS, NULL},
   48146             :    { (char *)"webObj_updateFromString", _wrap_webObj_updateFromString, METH_VARARGS, NULL},
   48147             :    { (char *)"webObj_convertToString", _wrap_webObj_convertToString, METH_VARARGS, NULL},
   48148             :    { (char *)"webObj_swigregister", webObj_swigregister, METH_VARARGS, NULL},
   48149             :    { (char *)"styleObj_refcount_get", _wrap_styleObj_refcount_get, METH_VARARGS, NULL},
   48150             :    { (char *)"styleObj_symbolname_get", _wrap_styleObj_symbolname_get, METH_VARARGS, NULL},
   48151             :    { (char *)"styleObj_autoangle_set", _wrap_styleObj_autoangle_set, METH_VARARGS, NULL},
   48152             :    { (char *)"styleObj_autoangle_get", _wrap_styleObj_autoangle_get, METH_VARARGS, NULL},
   48153             :    { (char *)"styleObj_color_set", _wrap_styleObj_color_set, METH_VARARGS, NULL},
   48154             :    { (char *)"styleObj_color_get", _wrap_styleObj_color_get, METH_VARARGS, NULL},
   48155             :    { (char *)"styleObj_backgroundcolor_set", _wrap_styleObj_backgroundcolor_set, METH_VARARGS, NULL},
   48156             :    { (char *)"styleObj_backgroundcolor_get", _wrap_styleObj_backgroundcolor_get, METH_VARARGS, NULL},
   48157             :    { (char *)"styleObj_outlinecolor_set", _wrap_styleObj_outlinecolor_set, METH_VARARGS, NULL},
   48158             :    { (char *)"styleObj_outlinecolor_get", _wrap_styleObj_outlinecolor_get, METH_VARARGS, NULL},
   48159             :    { (char *)"styleObj_opacity_set", _wrap_styleObj_opacity_set, METH_VARARGS, NULL},
   48160             :    { (char *)"styleObj_opacity_get", _wrap_styleObj_opacity_get, METH_VARARGS, NULL},
   48161             :    { (char *)"styleObj_mincolor_set", _wrap_styleObj_mincolor_set, METH_VARARGS, NULL},
   48162             :    { (char *)"styleObj_mincolor_get", _wrap_styleObj_mincolor_get, METH_VARARGS, NULL},
   48163             :    { (char *)"styleObj_maxcolor_set", _wrap_styleObj_maxcolor_set, METH_VARARGS, NULL},
   48164             :    { (char *)"styleObj_maxcolor_get", _wrap_styleObj_maxcolor_get, METH_VARARGS, NULL},
   48165             :    { (char *)"styleObj_minvalue_set", _wrap_styleObj_minvalue_set, METH_VARARGS, NULL},
   48166             :    { (char *)"styleObj_minvalue_get", _wrap_styleObj_minvalue_get, METH_VARARGS, NULL},
   48167             :    { (char *)"styleObj_maxvalue_set", _wrap_styleObj_maxvalue_set, METH_VARARGS, NULL},
   48168             :    { (char *)"styleObj_maxvalue_get", _wrap_styleObj_maxvalue_get, METH_VARARGS, NULL},
   48169             :    { (char *)"styleObj_rangeitem_set", _wrap_styleObj_rangeitem_set, METH_VARARGS, NULL},
   48170             :    { (char *)"styleObj_rangeitem_get", _wrap_styleObj_rangeitem_get, METH_VARARGS, NULL},
   48171             :    { (char *)"styleObj_rangeitemindex_set", _wrap_styleObj_rangeitemindex_set, METH_VARARGS, NULL},
   48172             :    { (char *)"styleObj_rangeitemindex_get", _wrap_styleObj_rangeitemindex_get, METH_VARARGS, NULL},
   48173             :    { (char *)"styleObj_symbol_set", _wrap_styleObj_symbol_set, METH_VARARGS, NULL},
   48174             :    { (char *)"styleObj_symbol_get", _wrap_styleObj_symbol_get, METH_VARARGS, NULL},
   48175             :    { (char *)"styleObj_size_set", _wrap_styleObj_size_set, METH_VARARGS, NULL},
   48176             :    { (char *)"styleObj_size_get", _wrap_styleObj_size_get, METH_VARARGS, NULL},
   48177             :    { (char *)"styleObj_minsize_set", _wrap_styleObj_minsize_set, METH_VARARGS, NULL},
   48178             :    { (char *)"styleObj_minsize_get", _wrap_styleObj_minsize_get, METH_VARARGS, NULL},
   48179             :    { (char *)"styleObj_maxsize_set", _wrap_styleObj_maxsize_set, METH_VARARGS, NULL},
   48180             :    { (char *)"styleObj_maxsize_get", _wrap_styleObj_maxsize_get, METH_VARARGS, NULL},
   48181             :    { (char *)"styleObj_patternlength_get", _wrap_styleObj_patternlength_get, METH_VARARGS, NULL},
   48182             :    { (char *)"styleObj_gap_set", _wrap_styleObj_gap_set, METH_VARARGS, NULL},
   48183             :    { (char *)"styleObj_gap_get", _wrap_styleObj_gap_get, METH_VARARGS, NULL},
   48184             :    { (char *)"styleObj_initialgap_set", _wrap_styleObj_initialgap_set, METH_VARARGS, NULL},
   48185             :    { (char *)"styleObj_initialgap_get", _wrap_styleObj_initialgap_get, METH_VARARGS, NULL},
   48186             :    { (char *)"styleObj_position_set", _wrap_styleObj_position_set, METH_VARARGS, NULL},
   48187             :    { (char *)"styleObj_position_get", _wrap_styleObj_position_get, METH_VARARGS, NULL},
   48188             :    { (char *)"styleObj_linecap_set", _wrap_styleObj_linecap_set, METH_VARARGS, NULL},
   48189             :    { (char *)"styleObj_linecap_get", _wrap_styleObj_linecap_get, METH_VARARGS, NULL},
   48190             :    { (char *)"styleObj_linejoin_set", _wrap_styleObj_linejoin_set, METH_VARARGS, NULL},
   48191             :    { (char *)"styleObj_linejoin_get", _wrap_styleObj_linejoin_get, METH_VARARGS, NULL},
   48192             :    { (char *)"styleObj_linejoinmaxsize_set", _wrap_styleObj_linejoinmaxsize_set, METH_VARARGS, NULL},
   48193             :    { (char *)"styleObj_linejoinmaxsize_get", _wrap_styleObj_linejoinmaxsize_get, METH_VARARGS, NULL},
   48194             :    { (char *)"styleObj_width_set", _wrap_styleObj_width_set, METH_VARARGS, NULL},
   48195             :    { (char *)"styleObj_width_get", _wrap_styleObj_width_get, METH_VARARGS, NULL},
   48196             :    { (char *)"styleObj_outlinewidth_set", _wrap_styleObj_outlinewidth_set, METH_VARARGS, NULL},
   48197             :    { (char *)"styleObj_outlinewidth_get", _wrap_styleObj_outlinewidth_get, METH_VARARGS, NULL},
   48198             :    { (char *)"styleObj_minwidth_set", _wrap_styleObj_minwidth_set, METH_VARARGS, NULL},
   48199             :    { (char *)"styleObj_minwidth_get", _wrap_styleObj_minwidth_get, METH_VARARGS, NULL},
   48200             :    { (char *)"styleObj_maxwidth_set", _wrap_styleObj_maxwidth_set, METH_VARARGS, NULL},
   48201             :    { (char *)"styleObj_maxwidth_get", _wrap_styleObj_maxwidth_get, METH_VARARGS, NULL},
   48202             :    { (char *)"styleObj_offsetx_set", _wrap_styleObj_offsetx_set, METH_VARARGS, NULL},
   48203             :    { (char *)"styleObj_offsetx_get", _wrap_styleObj_offsetx_get, METH_VARARGS, NULL},
   48204             :    { (char *)"styleObj_offsety_set", _wrap_styleObj_offsety_set, METH_VARARGS, NULL},
   48205             :    { (char *)"styleObj_offsety_get", _wrap_styleObj_offsety_get, METH_VARARGS, NULL},
   48206             :    { (char *)"styleObj_polaroffsetpixel_set", _wrap_styleObj_polaroffsetpixel_set, METH_VARARGS, NULL},
   48207             :    { (char *)"styleObj_polaroffsetpixel_get", _wrap_styleObj_polaroffsetpixel_get, METH_VARARGS, NULL},
   48208             :    { (char *)"styleObj_polaroffsetangle_set", _wrap_styleObj_polaroffsetangle_set, METH_VARARGS, NULL},
   48209             :    { (char *)"styleObj_polaroffsetangle_get", _wrap_styleObj_polaroffsetangle_get, METH_VARARGS, NULL},
   48210             :    { (char *)"styleObj_angle_set", _wrap_styleObj_angle_set, METH_VARARGS, NULL},
   48211             :    { (char *)"styleObj_angle_get", _wrap_styleObj_angle_get, METH_VARARGS, NULL},
   48212             :    { (char *)"styleObj_minscaledenom_set", _wrap_styleObj_minscaledenom_set, METH_VARARGS, NULL},
   48213             :    { (char *)"styleObj_minscaledenom_get", _wrap_styleObj_minscaledenom_get, METH_VARARGS, NULL},
   48214             :    { (char *)"styleObj_maxscaledenom_set", _wrap_styleObj_maxscaledenom_set, METH_VARARGS, NULL},
   48215             :    { (char *)"styleObj_maxscaledenom_get", _wrap_styleObj_maxscaledenom_get, METH_VARARGS, NULL},
   48216             :    { (char *)"styleObj_sizeunits_set", _wrap_styleObj_sizeunits_set, METH_VARARGS, NULL},
   48217             :    { (char *)"styleObj_sizeunits_get", _wrap_styleObj_sizeunits_get, METH_VARARGS, NULL},
   48218             :    { (char *)"new_styleObj", _wrap_new_styleObj, METH_VARARGS, NULL},
   48219             :    { (char *)"delete_styleObj", _wrap_delete_styleObj, METH_VARARGS, NULL},
   48220             :    { (char *)"styleObj_updateFromString", _wrap_styleObj_updateFromString, METH_VARARGS, NULL},
   48221             :    { (char *)"styleObj_convertToString", _wrap_styleObj_convertToString, METH_VARARGS, NULL},
   48222             :    { (char *)"styleObj_clone", _wrap_styleObj_clone, METH_VARARGS, NULL},
   48223             :    { (char *)"styleObj_setSymbolByName", _wrap_styleObj_setSymbolByName, METH_VARARGS, NULL},
   48224             :    { (char *)"styleObj_removeBinding", _wrap_styleObj_removeBinding, METH_VARARGS, NULL},
   48225             :    { (char *)"styleObj_setBinding", _wrap_styleObj_setBinding, METH_VARARGS, NULL},
   48226             :    { (char *)"styleObj_getBinding", _wrap_styleObj_getBinding, METH_VARARGS, NULL},
   48227             :    { (char *)"styleObj_getGeomTransform", _wrap_styleObj_getGeomTransform, METH_VARARGS, NULL},
   48228             :    { (char *)"styleObj_setGeomTransform", _wrap_styleObj_setGeomTransform, METH_VARARGS, NULL},
   48229             :    { (char *)"styleObj_pattern_set", _wrap_styleObj_pattern_set, METH_VARARGS, NULL},
   48230             :    { (char *)"styleObj_pattern_get", _wrap_styleObj_pattern_get, METH_VARARGS, NULL},
   48231             :    { (char *)"styleObj_swigregister", styleObj_swigregister, METH_VARARGS, NULL},
   48232             :    { (char *)"labelLeaderObj_maxdistance_set", _wrap_labelLeaderObj_maxdistance_set, METH_VARARGS, NULL},
   48233             :    { (char *)"labelLeaderObj_maxdistance_get", _wrap_labelLeaderObj_maxdistance_get, METH_VARARGS, NULL},
   48234             :    { (char *)"labelLeaderObj_gridstep_set", _wrap_labelLeaderObj_gridstep_set, METH_VARARGS, NULL},
   48235             :    { (char *)"labelLeaderObj_gridstep_get", _wrap_labelLeaderObj_gridstep_get, METH_VARARGS, NULL},
   48236             :    { (char *)"labelLeaderObj_numstyles_get", _wrap_labelLeaderObj_numstyles_get, METH_VARARGS, NULL},
   48237             :    { (char *)"new_labelLeaderObj", _wrap_new_labelLeaderObj, METH_VARARGS, NULL},
   48238             :    { (char *)"delete_labelLeaderObj", _wrap_delete_labelLeaderObj, METH_VARARGS, NULL},
   48239             :    { (char *)"labelLeaderObj_swigregister", labelLeaderObj_swigregister, METH_VARARGS, NULL},
   48240             :    { (char *)"labelObj_refcount_get", _wrap_labelObj_refcount_get, METH_VARARGS, NULL},
   48241             :    { (char *)"labelObj_font_set", _wrap_labelObj_font_set, METH_VARARGS, NULL},
   48242             :    { (char *)"labelObj_font_get", _wrap_labelObj_font_get, METH_VARARGS, NULL},
   48243             :    { (char *)"labelObj_color_set", _wrap_labelObj_color_set, METH_VARARGS, NULL},
   48244             :    { (char *)"labelObj_color_get", _wrap_labelObj_color_get, METH_VARARGS, NULL},
   48245             :    { (char *)"labelObj_outlinecolor_set", _wrap_labelObj_outlinecolor_set, METH_VARARGS, NULL},
   48246             :    { (char *)"labelObj_outlinecolor_get", _wrap_labelObj_outlinecolor_get, METH_VARARGS, NULL},
   48247             :    { (char *)"labelObj_outlinewidth_set", _wrap_labelObj_outlinewidth_set, METH_VARARGS, NULL},
   48248             :    { (char *)"labelObj_outlinewidth_get", _wrap_labelObj_outlinewidth_get, METH_VARARGS, NULL},
   48249             :    { (char *)"labelObj_shadowcolor_set", _wrap_labelObj_shadowcolor_set, METH_VARARGS, NULL},
   48250             :    { (char *)"labelObj_shadowcolor_get", _wrap_labelObj_shadowcolor_get, METH_VARARGS, NULL},
   48251             :    { (char *)"labelObj_shadowsizex_set", _wrap_labelObj_shadowsizex_set, METH_VARARGS, NULL},
   48252             :    { (char *)"labelObj_shadowsizex_get", _wrap_labelObj_shadowsizex_get, METH_VARARGS, NULL},
   48253             :    { (char *)"labelObj_shadowsizey_set", _wrap_labelObj_shadowsizey_set, METH_VARARGS, NULL},
   48254             :    { (char *)"labelObj_shadowsizey_get", _wrap_labelObj_shadowsizey_get, METH_VARARGS, NULL},
   48255             :    { (char *)"labelObj_size_set", _wrap_labelObj_size_set, METH_VARARGS, NULL},
   48256             :    { (char *)"labelObj_size_get", _wrap_labelObj_size_get, METH_VARARGS, NULL},
   48257             :    { (char *)"labelObj_minsize_set", _wrap_labelObj_minsize_set, METH_VARARGS, NULL},
   48258             :    { (char *)"labelObj_minsize_get", _wrap_labelObj_minsize_get, METH_VARARGS, NULL},
   48259             :    { (char *)"labelObj_maxsize_set", _wrap_labelObj_maxsize_set, METH_VARARGS, NULL},
   48260             :    { (char *)"labelObj_maxsize_get", _wrap_labelObj_maxsize_get, METH_VARARGS, NULL},
   48261             :    { (char *)"labelObj_position_set", _wrap_labelObj_position_set, METH_VARARGS, NULL},
   48262             :    { (char *)"labelObj_position_get", _wrap_labelObj_position_get, METH_VARARGS, NULL},
   48263             :    { (char *)"labelObj_offsetx_set", _wrap_labelObj_offsetx_set, METH_VARARGS, NULL},
   48264             :    { (char *)"labelObj_offsetx_get", _wrap_labelObj_offsetx_get, METH_VARARGS, NULL},
   48265             :    { (char *)"labelObj_offsety_set", _wrap_labelObj_offsety_set, METH_VARARGS, NULL},
   48266             :    { (char *)"labelObj_offsety_get", _wrap_labelObj_offsety_get, METH_VARARGS, NULL},
   48267             :    { (char *)"labelObj_angle_set", _wrap_labelObj_angle_set, METH_VARARGS, NULL},
   48268             :    { (char *)"labelObj_angle_get", _wrap_labelObj_angle_get, METH_VARARGS, NULL},
   48269             :    { (char *)"labelObj_anglemode_set", _wrap_labelObj_anglemode_set, METH_VARARGS, NULL},
   48270             :    { (char *)"labelObj_anglemode_get", _wrap_labelObj_anglemode_get, METH_VARARGS, NULL},
   48271             :    { (char *)"labelObj_buffer_set", _wrap_labelObj_buffer_set, METH_VARARGS, NULL},
   48272             :    { (char *)"labelObj_buffer_get", _wrap_labelObj_buffer_get, METH_VARARGS, NULL},
   48273             :    { (char *)"labelObj_align_set", _wrap_labelObj_align_set, METH_VARARGS, NULL},
   48274             :    { (char *)"labelObj_align_get", _wrap_labelObj_align_get, METH_VARARGS, NULL},
   48275             :    { (char *)"labelObj_wrap_set", _wrap_labelObj_wrap_set, METH_VARARGS, NULL},
   48276             :    { (char *)"labelObj_wrap_get", _wrap_labelObj_wrap_get, METH_VARARGS, NULL},
   48277             :    { (char *)"labelObj_maxlength_set", _wrap_labelObj_maxlength_set, METH_VARARGS, NULL},
   48278             :    { (char *)"labelObj_maxlength_get", _wrap_labelObj_maxlength_get, METH_VARARGS, NULL},
   48279             :    { (char *)"labelObj_minlength_set", _wrap_labelObj_minlength_set, METH_VARARGS, NULL},
   48280             :    { (char *)"labelObj_minlength_get", _wrap_labelObj_minlength_get, METH_VARARGS, NULL},
   48281             :    { (char *)"labelObj_space_size_10_set", _wrap_labelObj_space_size_10_set, METH_VARARGS, NULL},
   48282             :    { (char *)"labelObj_space_size_10_get", _wrap_labelObj_space_size_10_get, METH_VARARGS, NULL},
   48283             :    { (char *)"labelObj_minfeaturesize_set", _wrap_labelObj_minfeaturesize_set, METH_VARARGS, NULL},
   48284             :    { (char *)"labelObj_minfeaturesize_get", _wrap_labelObj_minfeaturesize_get, METH_VARARGS, NULL},
   48285             :    { (char *)"labelObj_autominfeaturesize_set", _wrap_labelObj_autominfeaturesize_set, METH_VARARGS, NULL},
   48286             :    { (char *)"labelObj_autominfeaturesize_get", _wrap_labelObj_autominfeaturesize_get, METH_VARARGS, NULL},
   48287             :    { (char *)"labelObj_minscaledenom_set", _wrap_labelObj_minscaledenom_set, METH_VARARGS, NULL},
   48288             :    { (char *)"labelObj_minscaledenom_get", _wrap_labelObj_minscaledenom_get, METH_VARARGS, NULL},
   48289             :    { (char *)"labelObj_maxscaledenom_set", _wrap_labelObj_maxscaledenom_set, METH_VARARGS, NULL},
   48290             :    { (char *)"labelObj_maxscaledenom_get", _wrap_labelObj_maxscaledenom_get, METH_VARARGS, NULL},
   48291             :    { (char *)"labelObj_mindistance_set", _wrap_labelObj_mindistance_set, METH_VARARGS, NULL},
   48292             :    { (char *)"labelObj_mindistance_get", _wrap_labelObj_mindistance_get, METH_VARARGS, NULL},
   48293             :    { (char *)"labelObj_repeatdistance_set", _wrap_labelObj_repeatdistance_set, METH_VARARGS, NULL},
   48294             :    { (char *)"labelObj_repeatdistance_get", _wrap_labelObj_repeatdistance_get, METH_VARARGS, NULL},
   48295             :    { (char *)"labelObj_maxoverlapangle_set", _wrap_labelObj_maxoverlapangle_set, METH_VARARGS, NULL},
   48296             :    { (char *)"labelObj_maxoverlapangle_get", _wrap_labelObj_maxoverlapangle_get, METH_VARARGS, NULL},
   48297             :    { (char *)"labelObj_partials_set", _wrap_labelObj_partials_set, METH_VARARGS, NULL},
   48298             :    { (char *)"labelObj_partials_get", _wrap_labelObj_partials_get, METH_VARARGS, NULL},
   48299             :    { (char *)"labelObj_force_set", _wrap_labelObj_force_set, METH_VARARGS, NULL},
   48300             :    { (char *)"labelObj_force_get", _wrap_labelObj_force_get, METH_VARARGS, NULL},
   48301             :    { (char *)"labelObj_encoding_set", _wrap_labelObj_encoding_set, METH_VARARGS, NULL},
   48302             :    { (char *)"labelObj_encoding_get", _wrap_labelObj_encoding_get, METH_VARARGS, NULL},
   48303             :    { (char *)"labelObj_priority_set", _wrap_labelObj_priority_set, METH_VARARGS, NULL},
   48304             :    { (char *)"labelObj_priority_get", _wrap_labelObj_priority_get, METH_VARARGS, NULL},
   48305             :    { (char *)"labelObj_numstyles_set", _wrap_labelObj_numstyles_set, METH_VARARGS, NULL},
   48306             :    { (char *)"labelObj_numstyles_get", _wrap_labelObj_numstyles_get, METH_VARARGS, NULL},
   48307             :    { (char *)"labelObj_leader_set", _wrap_labelObj_leader_set, METH_VARARGS, NULL},
   48308             :    { (char *)"labelObj_leader_get", _wrap_labelObj_leader_get, METH_VARARGS, NULL},
   48309             :    { (char *)"labelObj_sizeunits_set", _wrap_labelObj_sizeunits_set, METH_VARARGS, NULL},
   48310             :    { (char *)"labelObj_sizeunits_get", _wrap_labelObj_sizeunits_get, METH_VARARGS, NULL},
   48311             :    { (char *)"new_labelObj", _wrap_new_labelObj, METH_VARARGS, NULL},
   48312             :    { (char *)"delete_labelObj", _wrap_delete_labelObj, METH_VARARGS, NULL},
   48313             :    { (char *)"labelObj_updateFromString", _wrap_labelObj_updateFromString, METH_VARARGS, NULL},
   48314             :    { (char *)"labelObj_convertToString", _wrap_labelObj_convertToString, METH_VARARGS, NULL},
   48315             :    { (char *)"labelObj_removeBinding", _wrap_labelObj_removeBinding, METH_VARARGS, NULL},
   48316             :    { (char *)"labelObj_getBinding", _wrap_labelObj_getBinding, METH_VARARGS, NULL},
   48317             :    { (char *)"labelObj_setBinding", _wrap_labelObj_setBinding, METH_VARARGS, NULL},
   48318             :    { (char *)"labelObj_setExpression", _wrap_labelObj_setExpression, METH_VARARGS, NULL},
   48319             :    { (char *)"labelObj_getExpressionString", _wrap_labelObj_getExpressionString, METH_VARARGS, NULL},
   48320             :    { (char *)"labelObj_setText", _wrap_labelObj_setText, METH_VARARGS, NULL},
   48321             :    { (char *)"labelObj_getTextString", _wrap_labelObj_getTextString, METH_VARARGS, NULL},
   48322             :    { (char *)"labelObj_getStyle", _wrap_labelObj_getStyle, METH_VARARGS, NULL},
   48323             :    { (char *)"labelObj_insertStyle", _wrap_labelObj_insertStyle, METH_VARARGS, NULL},
   48324             :    { (char *)"labelObj_removeStyle", _wrap_labelObj_removeStyle, METH_VARARGS, NULL},
   48325             :    { (char *)"labelObj_moveStyleUp", _wrap_labelObj_moveStyleUp, METH_VARARGS, NULL},
   48326             :    { (char *)"labelObj_moveStyleDown", _wrap_labelObj_moveStyleDown, METH_VARARGS, NULL},
   48327             :    { (char *)"labelObj_swigregister", labelObj_swigregister, METH_VARARGS, NULL},
   48328             :    { (char *)"classObj_metadata_get", _wrap_classObj_metadata_get, METH_VARARGS, NULL},
   48329             :    { (char *)"classObj_validation_get", _wrap_classObj_validation_get, METH_VARARGS, NULL},
   48330             :    { (char *)"classObj_numstyles_get", _wrap_classObj_numstyles_get, METH_VARARGS, NULL},
   48331             :    { (char *)"classObj_numlabels_get", _wrap_classObj_numlabels_get, METH_VARARGS, NULL},
   48332             :    { (char *)"classObj_refcount_get", _wrap_classObj_refcount_get, METH_VARARGS, NULL},
   48333             :    { (char *)"classObj_layer_get", _wrap_classObj_layer_get, METH_VARARGS, NULL},
   48334             :    { (char *)"classObj_leader_get", _wrap_classObj_leader_get, METH_VARARGS, NULL},
   48335             :    { (char *)"classObj_status_set", _wrap_classObj_status_set, METH_VARARGS, NULL},
   48336             :    { (char *)"classObj_status_get", _wrap_classObj_status_get, METH_VARARGS, NULL},
   48337             :    { (char *)"classObj_isfallback_set", _wrap_classObj_isfallback_set, METH_VARARGS, NULL},
   48338             :    { (char *)"classObj_isfallback_get", _wrap_classObj_isfallback_get, METH_VARARGS, NULL},
   48339             :    { (char *)"classObj_name_set", _wrap_classObj_name_set, METH_VARARGS, NULL},
   48340             :    { (char *)"classObj_name_get", _wrap_classObj_name_get, METH_VARARGS, NULL},
   48341             :    { (char *)"classObj_title_set", _wrap_classObj_title_set, METH_VARARGS, NULL},
   48342             :    { (char *)"classObj_title_get", _wrap_classObj_title_get, METH_VARARGS, NULL},
   48343             :    { (char *)"classObj_minscaledenom_set", _wrap_classObj_minscaledenom_set, METH_VARARGS, NULL},
   48344             :    { (char *)"classObj_minscaledenom_get", _wrap_classObj_minscaledenom_get, METH_VARARGS, NULL},
   48345             :    { (char *)"classObj_maxscaledenom_set", _wrap_classObj_maxscaledenom_set, METH_VARARGS, NULL},
   48346             :    { (char *)"classObj_maxscaledenom_get", _wrap_classObj_maxscaledenom_get, METH_VARARGS, NULL},
   48347             :    { (char *)"classObj_minfeaturesize_set", _wrap_classObj_minfeaturesize_set, METH_VARARGS, NULL},
   48348             :    { (char *)"classObj_minfeaturesize_get", _wrap_classObj_minfeaturesize_get, METH_VARARGS, NULL},
   48349             :    { (char *)"classObj_debug_set", _wrap_classObj_debug_set, METH_VARARGS, NULL},
   48350             :    { (char *)"classObj_debug_get", _wrap_classObj_debug_get, METH_VARARGS, NULL},
   48351             :    { (char *)"classObj_keyimage_set", _wrap_classObj_keyimage_set, METH_VARARGS, NULL},
   48352             :    { (char *)"classObj_keyimage_get", _wrap_classObj_keyimage_get, METH_VARARGS, NULL},
   48353             :    { (char *)"classObj_group_set", _wrap_classObj_group_set, METH_VARARGS, NULL},
   48354             :    { (char *)"classObj_group_get", _wrap_classObj_group_get, METH_VARARGS, NULL},
   48355             :    { (char *)"classObj_sizeunits_set", _wrap_classObj_sizeunits_set, METH_VARARGS, NULL},
   48356             :    { (char *)"classObj_sizeunits_get", _wrap_classObj_sizeunits_get, METH_VARARGS, NULL},
   48357             :    { (char *)"classObj_template_set", _wrap_classObj_template_set, METH_VARARGS, NULL},
   48358             :    { (char *)"classObj_template_get", _wrap_classObj_template_get, METH_VARARGS, NULL},
   48359             :    { (char *)"new_classObj", _wrap_new_classObj, METH_VARARGS, NULL},
   48360             :    { (char *)"delete_classObj", _wrap_delete_classObj, METH_VARARGS, NULL},
   48361             :    { (char *)"classObj_updateFromString", _wrap_classObj_updateFromString, METH_VARARGS, NULL},
   48362             :    { (char *)"classObj_convertToString", _wrap_classObj_convertToString, METH_VARARGS, NULL},
   48363             :    { (char *)"classObj_clone", _wrap_classObj_clone, METH_VARARGS, NULL},
   48364             :    { (char *)"classObj_setExpression", _wrap_classObj_setExpression, METH_VARARGS, NULL},
   48365             :    { (char *)"classObj_getExpressionString", _wrap_classObj_getExpressionString, METH_VARARGS, NULL},
   48366             :    { (char *)"classObj_setText", _wrap_classObj_setText, METH_VARARGS, NULL},
   48367             :    { (char *)"classObj_getTextString", _wrap_classObj_getTextString, METH_VARARGS, NULL},
   48368             :    { (char *)"classObj_getMetaData", _wrap_classObj_getMetaData, METH_VARARGS, NULL},
   48369             :    { (char *)"classObj_setMetaData", _wrap_classObj_setMetaData, METH_VARARGS, NULL},
   48370             :    { (char *)"classObj_getFirstMetaDataKey", _wrap_classObj_getFirstMetaDataKey, METH_VARARGS, NULL},
   48371             :    { (char *)"classObj_getNextMetaDataKey", _wrap_classObj_getNextMetaDataKey, METH_VARARGS, NULL},
   48372             :    { (char *)"classObj_drawLegendIcon", _wrap_classObj_drawLegendIcon, METH_VARARGS, NULL},
   48373             :    { (char *)"classObj_createLegendIcon", _wrap_classObj_createLegendIcon, METH_VARARGS, NULL},
   48374             :    { (char *)"classObj_getLabel", _wrap_classObj_getLabel, METH_VARARGS, NULL},
   48375             :    { (char *)"classObj_addLabel", _wrap_classObj_addLabel, METH_VARARGS, NULL},
   48376             :    { (char *)"classObj_removeLabel", _wrap_classObj_removeLabel, METH_VARARGS, NULL},
   48377             :    { (char *)"classObj_getStyle", _wrap_classObj_getStyle, METH_VARARGS, NULL},
   48378             :    { (char *)"classObj_insertStyle", _wrap_classObj_insertStyle, METH_VARARGS, NULL},
   48379             :    { (char *)"classObj_removeStyle", _wrap_classObj_removeStyle, METH_VARARGS, NULL},
   48380             :    { (char *)"classObj_moveStyleUp", _wrap_classObj_moveStyleUp, METH_VARARGS, NULL},
   48381             :    { (char *)"classObj_moveStyleDown", _wrap_classObj_moveStyleDown, METH_VARARGS, NULL},
   48382             :    { (char *)"classObj_swigregister", classObj_swigregister, METH_VARARGS, NULL},
   48383             :    { (char *)"labelCacheMemberObj_textsymbols_get", _wrap_labelCacheMemberObj_textsymbols_get, METH_VARARGS, NULL},
   48384             :    { (char *)"labelCacheMemberObj_numtextsymbols_get", _wrap_labelCacheMemberObj_numtextsymbols_get, METH_VARARGS, NULL},
   48385             :    { (char *)"labelCacheMemberObj_layerindex_get", _wrap_labelCacheMemberObj_layerindex_get, METH_VARARGS, NULL},
   48386             :    { (char *)"labelCacheMemberObj_classindex_get", _wrap_labelCacheMemberObj_classindex_get, METH_VARARGS, NULL},
   48387             :    { (char *)"labelCacheMemberObj_point_get", _wrap_labelCacheMemberObj_point_get, METH_VARARGS, NULL},
   48388             :    { (char *)"labelCacheMemberObj_bbox_get", _wrap_labelCacheMemberObj_bbox_get, METH_VARARGS, NULL},
   48389             :    { (char *)"labelCacheMemberObj_status_get", _wrap_labelCacheMemberObj_status_get, METH_VARARGS, NULL},
   48390             :    { (char *)"labelCacheMemberObj_markerid_get", _wrap_labelCacheMemberObj_markerid_get, METH_VARARGS, NULL},
   48391             :    { (char *)"labelCacheMemberObj_leaderline_get", _wrap_labelCacheMemberObj_leaderline_get, METH_VARARGS, NULL},
   48392             :    { (char *)"labelCacheMemberObj_leaderbbox_get", _wrap_labelCacheMemberObj_leaderbbox_get, METH_VARARGS, NULL},
   48393             :    { (char *)"new_labelCacheMemberObj", _wrap_new_labelCacheMemberObj, METH_VARARGS, NULL},
   48394             :    { (char *)"delete_labelCacheMemberObj", _wrap_delete_labelCacheMemberObj, METH_VARARGS, NULL},
   48395             :    { (char *)"labelCacheMemberObj_swigregister", labelCacheMemberObj_swigregister, METH_VARARGS, NULL},
   48396             :    { (char *)"markerCacheMemberObj_id_get", _wrap_markerCacheMemberObj_id_get, METH_VARARGS, NULL},
   48397             :    { (char *)"markerCacheMemberObj_bounds_get", _wrap_markerCacheMemberObj_bounds_get, METH_VARARGS, NULL},
   48398             :    { (char *)"new_markerCacheMemberObj", _wrap_new_markerCacheMemberObj, METH_VARARGS, NULL},
   48399             :    { (char *)"delete_markerCacheMemberObj", _wrap_delete_markerCacheMemberObj, METH_VARARGS, NULL},
   48400             :    { (char *)"markerCacheMemberObj_swigregister", markerCacheMemberObj_swigregister, METH_VARARGS, NULL},
   48401             :    { (char *)"labelCacheSlotObj_labels_get", _wrap_labelCacheSlotObj_labels_get, METH_VARARGS, NULL},
   48402             :    { (char *)"labelCacheSlotObj_numlabels_get", _wrap_labelCacheSlotObj_numlabels_get, METH_VARARGS, NULL},
   48403             :    { (char *)"labelCacheSlotObj_cachesize_get", _wrap_labelCacheSlotObj_cachesize_get, METH_VARARGS, NULL},
   48404             :    { (char *)"labelCacheSlotObj_markers_get", _wrap_labelCacheSlotObj_markers_get, METH_VARARGS, NULL},
   48405             :    { (char *)"labelCacheSlotObj_nummarkers_get", _wrap_labelCacheSlotObj_nummarkers_get, METH_VARARGS, NULL},
   48406             :    { (char *)"labelCacheSlotObj_markercachesize_get", _wrap_labelCacheSlotObj_markercachesize_get, METH_VARARGS, NULL},
   48407             :    { (char *)"new_labelCacheSlotObj", _wrap_new_labelCacheSlotObj, METH_VARARGS, NULL},
   48408             :    { (char *)"delete_labelCacheSlotObj", _wrap_delete_labelCacheSlotObj, METH_VARARGS, NULL},
   48409             :    { (char *)"labelCacheSlotObj_swigregister", labelCacheSlotObj_swigregister, METH_VARARGS, NULL},
   48410             :    { (char *)"labelCacheObj_slots_get", _wrap_labelCacheObj_slots_get, METH_VARARGS, NULL},
   48411             :    { (char *)"labelCacheObj_gutter_get", _wrap_labelCacheObj_gutter_get, METH_VARARGS, NULL},
   48412             :    { (char *)"labelCacheObj_rendered_text_symbols_get", _wrap_labelCacheObj_rendered_text_symbols_get, METH_VARARGS, NULL},
   48413             :    { (char *)"labelCacheObj_num_allocated_rendered_members_get", _wrap_labelCacheObj_num_allocated_rendered_members_get, METH_VARARGS, NULL},
   48414             :    { (char *)"labelCacheObj_num_rendered_members_get", _wrap_labelCacheObj_num_rendered_members_get, METH_VARARGS, NULL},
   48415             :    { (char *)"labelCacheObj_freeCache", _wrap_labelCacheObj_freeCache, METH_VARARGS, NULL},
   48416             :    { (char *)"new_labelCacheObj", _wrap_new_labelCacheObj, METH_VARARGS, NULL},
   48417             :    { (char *)"delete_labelCacheObj", _wrap_delete_labelCacheObj, METH_VARARGS, NULL},
   48418             :    { (char *)"labelCacheObj_swigregister", labelCacheObj_swigregister, METH_VARARGS, NULL},
   48419             :    { (char *)"resultObj_shapeindex_get", _wrap_resultObj_shapeindex_get, METH_VARARGS, NULL},
   48420             :    { (char *)"resultObj_tileindex_get", _wrap_resultObj_tileindex_get, METH_VARARGS, NULL},
   48421             :    { (char *)"resultObj_resultindex_get", _wrap_resultObj_resultindex_get, METH_VARARGS, NULL},
   48422             :    { (char *)"resultObj_classindex_get", _wrap_resultObj_classindex_get, METH_VARARGS, NULL},
   48423             :    { (char *)"new_resultObj", _wrap_new_resultObj, METH_VARARGS, NULL},
   48424             :    { (char *)"delete_resultObj", _wrap_delete_resultObj, METH_VARARGS, NULL},
   48425             :    { (char *)"resultObj_swigregister", resultObj_swigregister, METH_VARARGS, NULL},
   48426             :    { (char *)"resultCacheObj_numresults_get", _wrap_resultCacheObj_numresults_get, METH_VARARGS, NULL},
   48427             :    { (char *)"resultCacheObj_bounds_get", _wrap_resultCacheObj_bounds_get, METH_VARARGS, NULL},
   48428             :    { (char *)"resultCacheObj_usegetshape_set", _wrap_resultCacheObj_usegetshape_set, METH_VARARGS, NULL},
   48429             :    { (char *)"resultCacheObj_usegetshape_get", _wrap_resultCacheObj_usegetshape_get, METH_VARARGS, NULL},
   48430             :    { (char *)"resultCacheObj_getResult", _wrap_resultCacheObj_getResult, METH_VARARGS, NULL},
   48431             :    { (char *)"new_resultCacheObj", _wrap_new_resultCacheObj, METH_VARARGS, NULL},
   48432             :    { (char *)"delete_resultCacheObj", _wrap_delete_resultCacheObj, METH_VARARGS, NULL},
   48433             :    { (char *)"resultCacheObj_swigregister", resultCacheObj_swigregister, METH_VARARGS, NULL},
   48434             :    { (char *)"symbolSetObj_filename_set", _wrap_symbolSetObj_filename_set, METH_VARARGS, NULL},
   48435             :    { (char *)"symbolSetObj_filename_get", _wrap_symbolSetObj_filename_get, METH_VARARGS, NULL},
   48436             :    { (char *)"symbolSetObj_imagecachesize_set", _wrap_symbolSetObj_imagecachesize_set, METH_VARARGS, NULL},
   48437             :    { (char *)"symbolSetObj_imagecachesize_get", _wrap_symbolSetObj_imagecachesize_get, METH_VARARGS, NULL},
   48438             :    { (char *)"symbolSetObj_numsymbols_get", _wrap_symbolSetObj_numsymbols_get, METH_VARARGS, NULL},
   48439             :    { (char *)"symbolSetObj_maxsymbols_get", _wrap_symbolSetObj_maxsymbols_get, METH_VARARGS, NULL},
   48440             :    { (char *)"new_symbolSetObj", _wrap_new_symbolSetObj, METH_VARARGS, NULL},
   48441             :    { (char *)"delete_symbolSetObj", _wrap_delete_symbolSetObj, METH_VARARGS, NULL},
   48442             :    { (char *)"symbolSetObj_getSymbol", _wrap_symbolSetObj_getSymbol, METH_VARARGS, NULL},
   48443             :    { (char *)"symbolSetObj_getSymbolByName", _wrap_symbolSetObj_getSymbolByName, METH_VARARGS, NULL},
   48444             :    { (char *)"symbolSetObj_index", _wrap_symbolSetObj_index, METH_VARARGS, NULL},
   48445             :    { (char *)"symbolSetObj_appendSymbol", _wrap_symbolSetObj_appendSymbol, METH_VARARGS, NULL},
   48446             :    { (char *)"symbolSetObj_removeSymbol", _wrap_symbolSetObj_removeSymbol, METH_VARARGS, NULL},
   48447             :    { (char *)"symbolSetObj_save", _wrap_symbolSetObj_save, METH_VARARGS, NULL},
   48448             :    { (char *)"symbolSetObj_swigregister", symbolSetObj_swigregister, METH_VARARGS, NULL},
   48449             :    { (char *)"referenceMapObj_extent_set", _wrap_referenceMapObj_extent_set, METH_VARARGS, NULL},
   48450             :    { (char *)"referenceMapObj_extent_get", _wrap_referenceMapObj_extent_get, METH_VARARGS, NULL},
   48451             :    { (char *)"referenceMapObj_height_set", _wrap_referenceMapObj_height_set, METH_VARARGS, NULL},
   48452             :    { (char *)"referenceMapObj_height_get", _wrap_referenceMapObj_height_get, METH_VARARGS, NULL},
   48453             :    { (char *)"referenceMapObj_width_set", _wrap_referenceMapObj_width_set, METH_VARARGS, NULL},
   48454             :    { (char *)"referenceMapObj_width_get", _wrap_referenceMapObj_width_get, METH_VARARGS, NULL},
   48455             :    { (char *)"referenceMapObj_color_set", _wrap_referenceMapObj_color_set, METH_VARARGS, NULL},
   48456             :    { (char *)"referenceMapObj_color_get", _wrap_referenceMapObj_color_get, METH_VARARGS, NULL},
   48457             :    { (char *)"referenceMapObj_outlinecolor_set", _wrap_referenceMapObj_outlinecolor_set, METH_VARARGS, NULL},
   48458             :    { (char *)"referenceMapObj_outlinecolor_get", _wrap_referenceMapObj_outlinecolor_get, METH_VARARGS, NULL},
   48459             :    { (char *)"referenceMapObj_image_set", _wrap_referenceMapObj_image_set, METH_VARARGS, NULL},
   48460             :    { (char *)"referenceMapObj_image_get", _wrap_referenceMapObj_image_get, METH_VARARGS, NULL},
   48461             :    { (char *)"referenceMapObj_status_set", _wrap_referenceMapObj_status_set, METH_VARARGS, NULL},
   48462             :    { (char *)"referenceMapObj_status_get", _wrap_referenceMapObj_status_get, METH_VARARGS, NULL},
   48463             :    { (char *)"referenceMapObj_marker_set", _wrap_referenceMapObj_marker_set, METH_VARARGS, NULL},
   48464             :    { (char *)"referenceMapObj_marker_get", _wrap_referenceMapObj_marker_get, METH_VARARGS, NULL},
   48465             :    { (char *)"referenceMapObj_markername_set", _wrap_referenceMapObj_markername_set, METH_VARARGS, NULL},
   48466             :    { (char *)"referenceMapObj_markername_get", _wrap_referenceMapObj_markername_get, METH_VARARGS, NULL},
   48467             :    { (char *)"referenceMapObj_markersize_set", _wrap_referenceMapObj_markersize_set, METH_VARARGS, NULL},
   48468             :    { (char *)"referenceMapObj_markersize_get", _wrap_referenceMapObj_markersize_get, METH_VARARGS, NULL},
   48469             :    { (char *)"referenceMapObj_minboxsize_set", _wrap_referenceMapObj_minboxsize_set, METH_VARARGS, NULL},
   48470             :    { (char *)"referenceMapObj_minboxsize_get", _wrap_referenceMapObj_minboxsize_get, METH_VARARGS, NULL},
   48471             :    { (char *)"referenceMapObj_maxboxsize_set", _wrap_referenceMapObj_maxboxsize_set, METH_VARARGS, NULL},
   48472             :    { (char *)"referenceMapObj_maxboxsize_get", _wrap_referenceMapObj_maxboxsize_get, METH_VARARGS, NULL},
   48473             :    { (char *)"referenceMapObj_map_get", _wrap_referenceMapObj_map_get, METH_VARARGS, NULL},
   48474             :    { (char *)"referenceMapObj_updateFromString", _wrap_referenceMapObj_updateFromString, METH_VARARGS, NULL},
   48475             :    { (char *)"referenceMapObj_convertToString", _wrap_referenceMapObj_convertToString, METH_VARARGS, NULL},
   48476             :    { (char *)"new_referenceMapObj", _wrap_new_referenceMapObj, METH_VARARGS, NULL},
   48477             :    { (char *)"delete_referenceMapObj", _wrap_delete_referenceMapObj, METH_VARARGS, NULL},
   48478             :    { (char *)"referenceMapObj_swigregister", referenceMapObj_swigregister, METH_VARARGS, NULL},
   48479             :    { (char *)"scalebarObj_imagecolor_set", _wrap_scalebarObj_imagecolor_set, METH_VARARGS, NULL},
   48480             :    { (char *)"scalebarObj_imagecolor_get", _wrap_scalebarObj_imagecolor_get, METH_VARARGS, NULL},
   48481             :    { (char *)"scalebarObj_height_set", _wrap_scalebarObj_height_set, METH_VARARGS, NULL},
   48482             :    { (char *)"scalebarObj_height_get", _wrap_scalebarObj_height_get, METH_VARARGS, NULL},
   48483             :    { (char *)"scalebarObj_width_set", _wrap_scalebarObj_width_set, METH_VARARGS, NULL},
   48484             :    { (char *)"scalebarObj_width_get", _wrap_scalebarObj_width_get, METH_VARARGS, NULL},
   48485             :    { (char *)"scalebarObj_style_set", _wrap_scalebarObj_style_set, METH_VARARGS, NULL},
   48486             :    { (char *)"scalebarObj_style_get", _wrap_scalebarObj_style_get, METH_VARARGS, NULL},
   48487             :    { (char *)"scalebarObj_intervals_set", _wrap_scalebarObj_intervals_set, METH_VARARGS, NULL},
   48488             :    { (char *)"scalebarObj_intervals_get", _wrap_scalebarObj_intervals_get, METH_VARARGS, NULL},
   48489             :    { (char *)"scalebarObj_label_set", _wrap_scalebarObj_label_set, METH_VARARGS, NULL},
   48490             :    { (char *)"scalebarObj_label_get", _wrap_scalebarObj_label_get, METH_VARARGS, NULL},
   48491             :    { (char *)"scalebarObj_color_set", _wrap_scalebarObj_color_set, METH_VARARGS, NULL},
   48492             :    { (char *)"scalebarObj_color_get", _wrap_scalebarObj_color_get, METH_VARARGS, NULL},
   48493             :    { (char *)"scalebarObj_backgroundcolor_set", _wrap_scalebarObj_backgroundcolor_set, METH_VARARGS, NULL},
   48494             :    { (char *)"scalebarObj_backgroundcolor_get", _wrap_scalebarObj_backgroundcolor_get, METH_VARARGS, NULL},
   48495             :    { (char *)"scalebarObj_outlinecolor_set", _wrap_scalebarObj_outlinecolor_set, METH_VARARGS, NULL},
   48496             :    { (char *)"scalebarObj_outlinecolor_get", _wrap_scalebarObj_outlinecolor_get, METH_VARARGS, NULL},
   48497             :    { (char *)"scalebarObj_units_set", _wrap_scalebarObj_units_set, METH_VARARGS, NULL},
   48498             :    { (char *)"scalebarObj_units_get", _wrap_scalebarObj_units_get, METH_VARARGS, NULL},
   48499             :    { (char *)"scalebarObj_status_set", _wrap_scalebarObj_status_set, METH_VARARGS, NULL},
   48500             :    { (char *)"scalebarObj_status_get", _wrap_scalebarObj_status_get, METH_VARARGS, NULL},
   48501             :    { (char *)"scalebarObj_position_set", _wrap_scalebarObj_position_set, METH_VARARGS, NULL},
   48502             :    { (char *)"scalebarObj_position_get", _wrap_scalebarObj_position_get, METH_VARARGS, NULL},
   48503             :    { (char *)"scalebarObj_postlabelcache_set", _wrap_scalebarObj_postlabelcache_set, METH_VARARGS, NULL},
   48504             :    { (char *)"scalebarObj_postlabelcache_get", _wrap_scalebarObj_postlabelcache_get, METH_VARARGS, NULL},
   48505             :    { (char *)"scalebarObj_align_set", _wrap_scalebarObj_align_set, METH_VARARGS, NULL},
   48506             :    { (char *)"scalebarObj_align_get", _wrap_scalebarObj_align_get, METH_VARARGS, NULL},
   48507             :    { (char *)"scalebarObj_offsetx_set", _wrap_scalebarObj_offsetx_set, METH_VARARGS, NULL},
   48508             :    { (char *)"scalebarObj_offsetx_get", _wrap_scalebarObj_offsetx_get, METH_VARARGS, NULL},
   48509             :    { (char *)"scalebarObj_offsety_set", _wrap_scalebarObj_offsety_set, METH_VARARGS, NULL},
   48510             :    { (char *)"scalebarObj_offsety_get", _wrap_scalebarObj_offsety_get, METH_VARARGS, NULL},
   48511             :    { (char *)"scalebarObj_updateFromString", _wrap_scalebarObj_updateFromString, METH_VARARGS, NULL},
   48512             :    { (char *)"scalebarObj_convertToString", _wrap_scalebarObj_convertToString, METH_VARARGS, NULL},
   48513             :    { (char *)"new_scalebarObj", _wrap_new_scalebarObj, METH_VARARGS, NULL},
   48514             :    { (char *)"delete_scalebarObj", _wrap_delete_scalebarObj, METH_VARARGS, NULL},
   48515             :    { (char *)"scalebarObj_swigregister", scalebarObj_swigregister, METH_VARARGS, NULL},
   48516             :    { (char *)"legendObj_imagecolor_set", _wrap_legendObj_imagecolor_set, METH_VARARGS, NULL},
   48517             :    { (char *)"legendObj_imagecolor_get", _wrap_legendObj_imagecolor_get, METH_VARARGS, NULL},
   48518             :    { (char *)"legendObj_label_get", _wrap_legendObj_label_get, METH_VARARGS, NULL},
   48519             :    { (char *)"legendObj_keysizex_set", _wrap_legendObj_keysizex_set, METH_VARARGS, NULL},
   48520             :    { (char *)"legendObj_keysizex_get", _wrap_legendObj_keysizex_get, METH_VARARGS, NULL},
   48521             :    { (char *)"legendObj_keysizey_set", _wrap_legendObj_keysizey_set, METH_VARARGS, NULL},
   48522             :    { (char *)"legendObj_keysizey_get", _wrap_legendObj_keysizey_get, METH_VARARGS, NULL},
   48523             :    { (char *)"legendObj_keyspacingx_set", _wrap_legendObj_keyspacingx_set, METH_VARARGS, NULL},
   48524             :    { (char *)"legendObj_keyspacingx_get", _wrap_legendObj_keyspacingx_get, METH_VARARGS, NULL},
   48525             :    { (char *)"legendObj_keyspacingy_set", _wrap_legendObj_keyspacingy_set, METH_VARARGS, NULL},
   48526             :    { (char *)"legendObj_keyspacingy_get", _wrap_legendObj_keyspacingy_get, METH_VARARGS, NULL},
   48527             :    { (char *)"legendObj_outlinecolor_set", _wrap_legendObj_outlinecolor_set, METH_VARARGS, NULL},
   48528             :    { (char *)"legendObj_outlinecolor_get", _wrap_legendObj_outlinecolor_get, METH_VARARGS, NULL},
   48529             :    { (char *)"legendObj_status_set", _wrap_legendObj_status_set, METH_VARARGS, NULL},
   48530             :    { (char *)"legendObj_status_get", _wrap_legendObj_status_get, METH_VARARGS, NULL},
   48531             :    { (char *)"legendObj_height_set", _wrap_legendObj_height_set, METH_VARARGS, NULL},
   48532             :    { (char *)"legendObj_height_get", _wrap_legendObj_height_get, METH_VARARGS, NULL},
   48533             :    { (char *)"legendObj_width_set", _wrap_legendObj_width_set, METH_VARARGS, NULL},
   48534             :    { (char *)"legendObj_width_get", _wrap_legendObj_width_get, METH_VARARGS, NULL},
   48535             :    { (char *)"legendObj_position_set", _wrap_legendObj_position_set, METH_VARARGS, NULL},
   48536             :    { (char *)"legendObj_position_get", _wrap_legendObj_position_get, METH_VARARGS, NULL},
   48537             :    { (char *)"legendObj_postlabelcache_set", _wrap_legendObj_postlabelcache_set, METH_VARARGS, NULL},
   48538             :    { (char *)"legendObj_postlabelcache_get", _wrap_legendObj_postlabelcache_get, METH_VARARGS, NULL},
   48539             :    { (char *)"legendObj_template_set", _wrap_legendObj_template_set, METH_VARARGS, NULL},
   48540             :    { (char *)"legendObj_template_get", _wrap_legendObj_template_get, METH_VARARGS, NULL},
   48541             :    { (char *)"legendObj_map_get", _wrap_legendObj_map_get, METH_VARARGS, NULL},
   48542             :    { (char *)"legendObj_updateFromString", _wrap_legendObj_updateFromString, METH_VARARGS, NULL},
   48543             :    { (char *)"legendObj_convertToString", _wrap_legendObj_convertToString, METH_VARARGS, NULL},
   48544             :    { (char *)"new_legendObj", _wrap_new_legendObj, METH_VARARGS, NULL},
   48545             :    { (char *)"delete_legendObj", _wrap_delete_legendObj, METH_VARARGS, NULL},
   48546             :    { (char *)"legendObj_swigregister", legendObj_swigregister, METH_VARARGS, NULL},
   48547             :    { (char *)"imageObj_width_get", _wrap_imageObj_width_get, METH_VARARGS, NULL},
   48548             :    { (char *)"imageObj_height_get", _wrap_imageObj_height_get, METH_VARARGS, NULL},
   48549             :    { (char *)"imageObj_resolution_get", _wrap_imageObj_resolution_get, METH_VARARGS, NULL},
   48550             :    { (char *)"imageObj_resolutionfactor_get", _wrap_imageObj_resolutionfactor_get, METH_VARARGS, NULL},
   48551             :    { (char *)"imageObj_imagepath_get", _wrap_imageObj_imagepath_get, METH_VARARGS, NULL},
   48552             :    { (char *)"imageObj_imageurl_get", _wrap_imageObj_imageurl_get, METH_VARARGS, NULL},
   48553             :    { (char *)"imageObj_format_get", _wrap_imageObj_format_get, METH_VARARGS, NULL},
   48554             :    { (char *)"new_imageObj", _wrap_new_imageObj, METH_VARARGS, NULL},
   48555             :    { (char *)"delete_imageObj", _wrap_delete_imageObj, METH_VARARGS, NULL},
   48556             :    { (char *)"imageObj_save", _wrap_imageObj_save, METH_VARARGS, NULL},
   48557             :    { (char *)"imageObj_getBytes", _wrap_imageObj_getBytes, METH_VARARGS, NULL},
   48558             :    { (char *)"imageObj_getSize", _wrap_imageObj_getSize, METH_VARARGS, NULL},
   48559             :    { (char *)"imageObj_write", _wrap_imageObj_write, METH_VARARGS, NULL},
   48560             :    { (char *)"imageObj_saveToString", _wrap_imageObj_saveToString, METH_VARARGS, NULL},
   48561             :    { (char *)"imageObj_swigregister", imageObj_swigregister, METH_VARARGS, NULL},
   48562             :    { (char *)"scaleTokenEntryObj_minscale_set", _wrap_scaleTokenEntryObj_minscale_set, METH_VARARGS, NULL},
   48563             :    { (char *)"scaleTokenEntryObj_minscale_get", _wrap_scaleTokenEntryObj_minscale_get, METH_VARARGS, NULL},
   48564             :    { (char *)"scaleTokenEntryObj_maxscale_set", _wrap_scaleTokenEntryObj_maxscale_set, METH_VARARGS, NULL},
   48565             :    { (char *)"scaleTokenEntryObj_maxscale_get", _wrap_scaleTokenEntryObj_maxscale_get, METH_VARARGS, NULL},
   48566             :    { (char *)"scaleTokenEntryObj_value_set", _wrap_scaleTokenEntryObj_value_set, METH_VARARGS, NULL},
   48567             :    { (char *)"scaleTokenEntryObj_value_get", _wrap_scaleTokenEntryObj_value_get, METH_VARARGS, NULL},
   48568             :    { (char *)"new_scaleTokenEntryObj", _wrap_new_scaleTokenEntryObj, METH_VARARGS, NULL},
   48569             :    { (char *)"delete_scaleTokenEntryObj", _wrap_delete_scaleTokenEntryObj, METH_VARARGS, NULL},
   48570             :    { (char *)"scaleTokenEntryObj_swigregister", scaleTokenEntryObj_swigregister, METH_VARARGS, NULL},
   48571             :    { (char *)"scaleTokenObj_name_set", _wrap_scaleTokenObj_name_set, METH_VARARGS, NULL},
   48572             :    { (char *)"scaleTokenObj_name_get", _wrap_scaleTokenObj_name_get, METH_VARARGS, NULL},
   48573             :    { (char *)"scaleTokenObj_n_entries_set", _wrap_scaleTokenObj_n_entries_set, METH_VARARGS, NULL},
   48574             :    { (char *)"scaleTokenObj_n_entries_get", _wrap_scaleTokenObj_n_entries_get, METH_VARARGS, NULL},
   48575             :    { (char *)"scaleTokenObj_tokens_set", _wrap_scaleTokenObj_tokens_set, METH_VARARGS, NULL},
   48576             :    { (char *)"scaleTokenObj_tokens_get", _wrap_scaleTokenObj_tokens_get, METH_VARARGS, NULL},
   48577             :    { (char *)"new_scaleTokenObj", _wrap_new_scaleTokenObj, METH_VARARGS, NULL},
   48578             :    { (char *)"delete_scaleTokenObj", _wrap_delete_scaleTokenObj, METH_VARARGS, NULL},
   48579             :    { (char *)"scaleTokenObj_swigregister", scaleTokenObj_swigregister, METH_VARARGS, NULL},
   48580             :    { (char *)"layerObj_classitem_set", _wrap_layerObj_classitem_set, METH_VARARGS, NULL},
   48581             :    { (char *)"layerObj_classitem_get", _wrap_layerObj_classitem_get, METH_VARARGS, NULL},
   48582             :    { (char *)"layerObj_refcount_get", _wrap_layerObj_refcount_get, METH_VARARGS, NULL},
   48583             :    { (char *)"layerObj_numclasses_get", _wrap_layerObj_numclasses_get, METH_VARARGS, NULL},
   48584             :    { (char *)"layerObj_maxclasses_get", _wrap_layerObj_maxclasses_get, METH_VARARGS, NULL},
   48585             :    { (char *)"layerObj_index_get", _wrap_layerObj_index_get, METH_VARARGS, NULL},
   48586             :    { (char *)"layerObj_map_get", _wrap_layerObj_map_get, METH_VARARGS, NULL},
   48587             :    { (char *)"layerObj_header_set", _wrap_layerObj_header_set, METH_VARARGS, NULL},
   48588             :    { (char *)"layerObj_header_get", _wrap_layerObj_header_get, METH_VARARGS, NULL},
   48589             :    { (char *)"layerObj_footer_set", _wrap_layerObj_footer_set, METH_VARARGS, NULL},
   48590             :    { (char *)"layerObj_footer_get", _wrap_layerObj_footer_get, METH_VARARGS, NULL},
   48591             :    { (char *)"layerObj_template_set", _wrap_layerObj_template_set, METH_VARARGS, NULL},
   48592             :    { (char *)"layerObj_template_get", _wrap_layerObj_template_get, METH_VARARGS, NULL},
   48593             :    { (char *)"layerObj_name_set", _wrap_layerObj_name_set, METH_VARARGS, NULL},
   48594             :    { (char *)"layerObj_name_get", _wrap_layerObj_name_get, METH_VARARGS, NULL},
   48595             :    { (char *)"layerObj_group_set", _wrap_layerObj_group_set, METH_VARARGS, NULL},
   48596             :    { (char *)"layerObj_group_get", _wrap_layerObj_group_get, METH_VARARGS, NULL},
   48597             :    { (char *)"layerObj_status_set", _wrap_layerObj_status_set, METH_VARARGS, NULL},
   48598             :    { (char *)"layerObj_status_get", _wrap_layerObj_status_get, METH_VARARGS, NULL},
   48599             :    { (char *)"layerObj_rendermode_set", _wrap_layerObj_rendermode_set, METH_VARARGS, NULL},
   48600             :    { (char *)"layerObj_rendermode_get", _wrap_layerObj_rendermode_get, METH_VARARGS, NULL},
   48601             :    { (char *)"layerObj_data_set", _wrap_layerObj_data_set, METH_VARARGS, NULL},
   48602             :    { (char *)"layerObj_data_get", _wrap_layerObj_data_get, METH_VARARGS, NULL},
   48603             :    { (char *)"layerObj_type_set", _wrap_layerObj_type_set, METH_VARARGS, NULL},
   48604             :    { (char *)"layerObj_type_get", _wrap_layerObj_type_get, METH_VARARGS, NULL},
   48605             :    { (char *)"layerObj_tolerance_set", _wrap_layerObj_tolerance_set, METH_VARARGS, NULL},
   48606             :    { (char *)"layerObj_tolerance_get", _wrap_layerObj_tolerance_get, METH_VARARGS, NULL},
   48607             :    { (char *)"layerObj_toleranceunits_set", _wrap_layerObj_toleranceunits_set, METH_VARARGS, NULL},
   48608             :    { (char *)"layerObj_toleranceunits_get", _wrap_layerObj_toleranceunits_get, METH_VARARGS, NULL},
   48609             :    { (char *)"layerObj_symbolscaledenom_set", _wrap_layerObj_symbolscaledenom_set, METH_VARARGS, NULL},
   48610             :    { (char *)"layerObj_symbolscaledenom_get", _wrap_layerObj_symbolscaledenom_get, METH_VARARGS, NULL},
   48611             :    { (char *)"layerObj_minscaledenom_set", _wrap_layerObj_minscaledenom_set, METH_VARARGS, NULL},
   48612             :    { (char *)"layerObj_minscaledenom_get", _wrap_layerObj_minscaledenom_get, METH_VARARGS, NULL},
   48613             :    { (char *)"layerObj_maxscaledenom_set", _wrap_layerObj_maxscaledenom_set, METH_VARARGS, NULL},
   48614             :    { (char *)"layerObj_maxscaledenom_get", _wrap_layerObj_maxscaledenom_get, METH_VARARGS, NULL},
   48615             :    { (char *)"layerObj_minfeaturesize_set", _wrap_layerObj_minfeaturesize_set, METH_VARARGS, NULL},
   48616             :    { (char *)"layerObj_minfeaturesize_get", _wrap_layerObj_minfeaturesize_get, METH_VARARGS, NULL},
   48617             :    { (char *)"layerObj_labelminscaledenom_set", _wrap_layerObj_labelminscaledenom_set, METH_VARARGS, NULL},
   48618             :    { (char *)"layerObj_labelminscaledenom_get", _wrap_layerObj_labelminscaledenom_get, METH_VARARGS, NULL},
   48619             :    { (char *)"layerObj_labelmaxscaledenom_set", _wrap_layerObj_labelmaxscaledenom_set, METH_VARARGS, NULL},
   48620             :    { (char *)"layerObj_labelmaxscaledenom_get", _wrap_layerObj_labelmaxscaledenom_get, METH_VARARGS, NULL},
   48621             :    { (char *)"layerObj_mingeowidth_set", _wrap_layerObj_mingeowidth_set, METH_VARARGS, NULL},
   48622             :    { (char *)"layerObj_mingeowidth_get", _wrap_layerObj_mingeowidth_get, METH_VARARGS, NULL},
   48623             :    { (char *)"layerObj_maxgeowidth_set", _wrap_layerObj_maxgeowidth_set, METH_VARARGS, NULL},
   48624             :    { (char *)"layerObj_maxgeowidth_get", _wrap_layerObj_maxgeowidth_get, METH_VARARGS, NULL},
   48625             :    { (char *)"layerObj_sizeunits_set", _wrap_layerObj_sizeunits_set, METH_VARARGS, NULL},
   48626             :    { (char *)"layerObj_sizeunits_get", _wrap_layerObj_sizeunits_get, METH_VARARGS, NULL},
   48627             :    { (char *)"layerObj_maxfeatures_set", _wrap_layerObj_maxfeatures_set, METH_VARARGS, NULL},
   48628             :    { (char *)"layerObj_maxfeatures_get", _wrap_layerObj_maxfeatures_get, METH_VARARGS, NULL},
   48629             :    { (char *)"layerObj_startindex_set", _wrap_layerObj_startindex_set, METH_VARARGS, NULL},
   48630             :    { (char *)"layerObj_startindex_get", _wrap_layerObj_startindex_get, METH_VARARGS, NULL},
   48631             :    { (char *)"layerObj_offsite_set", _wrap_layerObj_offsite_set, METH_VARARGS, NULL},
   48632             :    { (char *)"layerObj_offsite_get", _wrap_layerObj_offsite_get, METH_VARARGS, NULL},
   48633             :    { (char *)"layerObj_transform_set", _wrap_layerObj_transform_set, METH_VARARGS, NULL},
   48634             :    { (char *)"layerObj_transform_get", _wrap_layerObj_transform_get, METH_VARARGS, NULL},
   48635             :    { (char *)"layerObj_labelcache_set", _wrap_layerObj_labelcache_set, METH_VARARGS, NULL},
   48636             :    { (char *)"layerObj_labelcache_get", _wrap_layerObj_labelcache_get, METH_VARARGS, NULL},
   48637             :    { (char *)"layerObj_postlabelcache_set", _wrap_layerObj_postlabelcache_set, METH_VARARGS, NULL},
   48638             :    { (char *)"layerObj_postlabelcache_get", _wrap_layerObj_postlabelcache_get, METH_VARARGS, NULL},
   48639             :    { (char *)"layerObj_labelitem_set", _wrap_layerObj_labelitem_set, METH_VARARGS, NULL},
   48640             :    { (char *)"layerObj_labelitem_get", _wrap_layerObj_labelitem_get, METH_VARARGS, NULL},
   48641             :    { (char *)"layerObj_tileitem_set", _wrap_layerObj_tileitem_set, METH_VARARGS, NULL},
   48642             :    { (char *)"layerObj_tileitem_get", _wrap_layerObj_tileitem_get, METH_VARARGS, NULL},
   48643             :    { (char *)"layerObj_tileindex_set", _wrap_layerObj_tileindex_set, METH_VARARGS, NULL},
   48644             :    { (char *)"layerObj_tileindex_get", _wrap_layerObj_tileindex_get, METH_VARARGS, NULL},
   48645             :    { (char *)"layerObj_tilesrs_set", _wrap_layerObj_tilesrs_set, METH_VARARGS, NULL},
   48646             :    { (char *)"layerObj_tilesrs_get", _wrap_layerObj_tilesrs_get, METH_VARARGS, NULL},
   48647             :    { (char *)"layerObj_units_set", _wrap_layerObj_units_set, METH_VARARGS, NULL},
   48648             :    { (char *)"layerObj_units_get", _wrap_layerObj_units_get, METH_VARARGS, NULL},
   48649             :    { (char *)"layerObj_connection_set", _wrap_layerObj_connection_set, METH_VARARGS, NULL},
   48650             :    { (char *)"layerObj_connection_get", _wrap_layerObj_connection_get, METH_VARARGS, NULL},
   48651             :    { (char *)"layerObj_plugin_library_set", _wrap_layerObj_plugin_library_set, METH_VARARGS, NULL},
   48652             :    { (char *)"layerObj_plugin_library_get", _wrap_layerObj_plugin_library_get, METH_VARARGS, NULL},
   48653             :    { (char *)"layerObj_plugin_library_original_set", _wrap_layerObj_plugin_library_original_set, METH_VARARGS, NULL},
   48654             :    { (char *)"layerObj_plugin_library_original_get", _wrap_layerObj_plugin_library_original_get, METH_VARARGS, NULL},
   48655             :    { (char *)"layerObj_connectiontype_set", _wrap_layerObj_connectiontype_set, METH_VARARGS, NULL},
   48656             :    { (char *)"layerObj_connectiontype_get", _wrap_layerObj_connectiontype_get, METH_VARARGS, NULL},
   48657             :    { (char *)"layerObj_numitems_get", _wrap_layerObj_numitems_get, METH_VARARGS, NULL},
   48658             :    { (char *)"layerObj_bandsitem_set", _wrap_layerObj_bandsitem_set, METH_VARARGS, NULL},
   48659             :    { (char *)"layerObj_bandsitem_get", _wrap_layerObj_bandsitem_get, METH_VARARGS, NULL},
   48660             :    { (char *)"layerObj_filteritem_set", _wrap_layerObj_filteritem_set, METH_VARARGS, NULL},
   48661             :    { (char *)"layerObj_filteritem_get", _wrap_layerObj_filteritem_get, METH_VARARGS, NULL},
   48662             :    { (char *)"layerObj_styleitem_set", _wrap_layerObj_styleitem_set, METH_VARARGS, NULL},
   48663             :    { (char *)"layerObj_styleitem_get", _wrap_layerObj_styleitem_get, METH_VARARGS, NULL},
   48664             :    { (char *)"layerObj_requires_set", _wrap_layerObj_requires_set, METH_VARARGS, NULL},
   48665             :    { (char *)"layerObj_requires_get", _wrap_layerObj_requires_get, METH_VARARGS, NULL},
   48666             :    { (char *)"layerObj_labelrequires_set", _wrap_layerObj_labelrequires_set, METH_VARARGS, NULL},
   48667             :    { (char *)"layerObj_labelrequires_get", _wrap_layerObj_labelrequires_get, METH_VARARGS, NULL},
   48668             :    { (char *)"layerObj_metadata_get", _wrap_layerObj_metadata_get, METH_VARARGS, NULL},
   48669             :    { (char *)"layerObj_validation_get", _wrap_layerObj_validation_get, METH_VARARGS, NULL},
   48670             :    { (char *)"layerObj_bindvals_get", _wrap_layerObj_bindvals_get, METH_VARARGS, NULL},
   48671             :    { (char *)"layerObj_cluster_get", _wrap_layerObj_cluster_get, METH_VARARGS, NULL},
   48672             :    { (char *)"layerObj_dump_set", _wrap_layerObj_dump_set, METH_VARARGS, NULL},
   48673             :    { (char *)"layerObj_dump_get", _wrap_layerObj_dump_get, METH_VARARGS, NULL},
   48674             :    { (char *)"layerObj_debug_set", _wrap_layerObj_debug_set, METH_VARARGS, NULL},
   48675             :    { (char *)"layerObj_debug_get", _wrap_layerObj_debug_get, METH_VARARGS, NULL},
   48676             :    { (char *)"layerObj_extent_get", _wrap_layerObj_extent_get, METH_VARARGS, NULL},
   48677             :    { (char *)"layerObj_numprocessing_get", _wrap_layerObj_numprocessing_get, METH_VARARGS, NULL},
   48678             :    { (char *)"layerObj_numjoins_get", _wrap_layerObj_numjoins_get, METH_VARARGS, NULL},
   48679             :    { (char *)"layerObj_classgroup_set", _wrap_layerObj_classgroup_set, METH_VARARGS, NULL},
   48680             :    { (char *)"layerObj_classgroup_get", _wrap_layerObj_classgroup_get, METH_VARARGS, NULL},
   48681             :    { (char *)"layerObj_mask_set", _wrap_layerObj_mask_set, METH_VARARGS, NULL},
   48682             :    { (char *)"layerObj_mask_get", _wrap_layerObj_mask_get, METH_VARARGS, NULL},
   48683             :    { (char *)"layerObj_encoding_set", _wrap_layerObj_encoding_set, METH_VARARGS, NULL},
   48684             :    { (char *)"layerObj_encoding_get", _wrap_layerObj_encoding_get, METH_VARARGS, NULL},
   48685             :    { (char *)"layerObj_utfitem_set", _wrap_layerObj_utfitem_set, METH_VARARGS, NULL},
   48686             :    { (char *)"layerObj_utfitem_get", _wrap_layerObj_utfitem_get, METH_VARARGS, NULL},
   48687             :    { (char *)"layerObj_utfitemindex_set", _wrap_layerObj_utfitemindex_set, METH_VARARGS, NULL},
   48688             :    { (char *)"layerObj_utfitemindex_get", _wrap_layerObj_utfitemindex_get, METH_VARARGS, NULL},
   48689             :    { (char *)"layerObj_utfdata_set", _wrap_layerObj_utfdata_set, METH_VARARGS, NULL},
   48690             :    { (char *)"layerObj_utfdata_get", _wrap_layerObj_utfdata_get, METH_VARARGS, NULL},
   48691             :    { (char *)"layerObj_compositer_set", _wrap_layerObj_compositer_set, METH_VARARGS, NULL},
   48692             :    { (char *)"layerObj_compositer_get", _wrap_layerObj_compositer_get, METH_VARARGS, NULL},
   48693             :    { (char *)"layerObj_connectionoptions_set", _wrap_layerObj_connectionoptions_set, METH_VARARGS, NULL},
   48694             :    { (char *)"layerObj_connectionoptions_get", _wrap_layerObj_connectionoptions_get, METH_VARARGS, NULL},
   48695             :    { (char *)"new_layerObj", _wrap_new_layerObj, METH_VARARGS, NULL},
   48696             :    { (char *)"layerObj_setOpacity", _wrap_layerObj_setOpacity, METH_VARARGS, NULL},
   48697             :    { (char *)"layerObj_getOpacity", _wrap_layerObj_getOpacity, METH_VARARGS, NULL},
   48698             :    { (char *)"delete_layerObj", _wrap_delete_layerObj, METH_VARARGS, NULL},
   48699             :    { (char *)"layerObj_clone", _wrap_layerObj_clone, METH_VARARGS, NULL},
   48700             :    { (char *)"layerObj_updateFromString", _wrap_layerObj_updateFromString, METH_VARARGS, NULL},
   48701             :    { (char *)"layerObj_convertToString", _wrap_layerObj_convertToString, METH_VARARGS, NULL},
   48702             :    { (char *)"layerObj_insertClass", _wrap_layerObj_insertClass, METH_VARARGS, NULL},
   48703             :    { (char *)"layerObj_removeClass", _wrap_layerObj_removeClass, METH_VARARGS, NULL},
   48704             :    { (char *)"layerObj_open", _wrap_layerObj_open, METH_VARARGS, NULL},
   48705             :    { (char *)"layerObj_whichShapes", _wrap_layerObj_whichShapes, METH_VARARGS, NULL},
   48706             :    { (char *)"layerObj_nextShape", _wrap_layerObj_nextShape, METH_VARARGS, NULL},
   48707             :    { (char *)"layerObj_close", _wrap_layerObj_close, METH_VARARGS, NULL},
   48708             :    { (char *)"layerObj_getShape", _wrap_layerObj_getShape, METH_VARARGS, NULL},
   48709             :    { (char *)"layerObj_getNumResults", _wrap_layerObj_getNumResults, METH_VARARGS, NULL},
   48710             :    { (char *)"layerObj_getResultsBounds", _wrap_layerObj_getResultsBounds, METH_VARARGS, NULL},
   48711             :    { (char *)"layerObj_getResult", _wrap_layerObj_getResult, METH_VARARGS, NULL},
   48712             :    { (char *)"layerObj_getClass", _wrap_layerObj_getClass, METH_VARARGS, NULL},
   48713             :    { (char *)"layerObj_getItem", _wrap_layerObj_getItem, METH_VARARGS, NULL},
   48714             :    { (char *)"layerObj_setItems", _wrap_layerObj_setItems, METH_VARARGS, NULL},
   48715             :    { (char *)"layerObj_draw", _wrap_layerObj_draw, METH_VARARGS, NULL},
   48716             :    { (char *)"layerObj_drawQuery", _wrap_layerObj_drawQuery, METH_VARARGS, NULL},
   48717             :    { (char *)"layerObj_queryByFilter", _wrap_layerObj_queryByFilter, METH_VARARGS, NULL},
   48718             :    { (char *)"layerObj_queryByAttributes", _wrap_layerObj_queryByAttributes, METH_VARARGS, NULL},
   48719             :    { (char *)"layerObj_queryByPoint", _wrap_layerObj_queryByPoint, METH_VARARGS, NULL},
   48720             :    { (char *)"layerObj_queryByRect", _wrap_layerObj_queryByRect, METH_VARARGS, NULL},
   48721             :    { (char *)"layerObj_queryByFeatures", _wrap_layerObj_queryByFeatures, METH_VARARGS, NULL},
   48722             :    { (char *)"layerObj_queryByShape", _wrap_layerObj_queryByShape, METH_VARARGS, NULL},
   48723             :    { (char *)"layerObj_queryByIndex", _wrap_layerObj_queryByIndex, METH_VARARGS, NULL},
   48724             :    { (char *)"layerObj_getResults", _wrap_layerObj_getResults, METH_VARARGS, NULL},
   48725             :    { (char *)"layerObj_setFilter", _wrap_layerObj_setFilter, METH_VARARGS, NULL},
   48726             :    { (char *)"layerObj_getFilterString", _wrap_layerObj_getFilterString, METH_VARARGS, NULL},
   48727             :    { (char *)"layerObj_setWKTProjection", _wrap_layerObj_setWKTProjection, METH_VARARGS, NULL},
   48728             :    { (char *)"layerObj_getProjection", _wrap_layerObj_getProjection, METH_VARARGS, NULL},
   48729             :    { (char *)"layerObj_setProjection", _wrap_layerObj_setProjection, METH_VARARGS, NULL},
   48730             :    { (char *)"layerObj_addFeature", _wrap_layerObj_addFeature, METH_VARARGS, NULL},
   48731             :    { (char *)"layerObj_getNumFeatures", _wrap_layerObj_getNumFeatures, METH_VARARGS, NULL},
   48732             :    { (char *)"layerObj_getExtent", _wrap_layerObj_getExtent, METH_VARARGS, NULL},
   48733             :    { (char *)"layerObj_setExtent", _wrap_layerObj_setExtent, METH_VARARGS, NULL},
   48734             :    { (char *)"layerObj_getMetaData", _wrap_layerObj_getMetaData, METH_VARARGS, NULL},
   48735             :    { (char *)"layerObj_setMetaData", _wrap_layerObj_setMetaData, METH_VARARGS, NULL},
   48736             :    { (char *)"layerObj_removeMetaData", _wrap_layerObj_removeMetaData, METH_VARARGS, NULL},
   48737             :    { (char *)"layerObj_getFirstMetaDataKey", _wrap_layerObj_getFirstMetaDataKey, METH_VARARGS, NULL},
   48738             :    { (char *)"layerObj_getNextMetaDataKey", _wrap_layerObj_getNextMetaDataKey, METH_VARARGS, NULL},
   48739             :    { (char *)"layerObj_getWMSFeatureInfoURL", _wrap_layerObj_getWMSFeatureInfoURL, METH_VARARGS, NULL},
   48740             :    { (char *)"layerObj_executeWFSGetFeature", _wrap_layerObj_executeWFSGetFeature, METH_VARARGS, NULL},
   48741             :    { (char *)"layerObj_applySLD", _wrap_layerObj_applySLD, METH_VARARGS, NULL},
   48742             :    { (char *)"layerObj_applySLDURL", _wrap_layerObj_applySLDURL, METH_VARARGS, NULL},
   48743             :    { (char *)"layerObj_generateSLD", _wrap_layerObj_generateSLD, METH_VARARGS, NULL},
   48744             :    { (char *)"layerObj_isVisible", _wrap_layerObj_isVisible, METH_VARARGS, NULL},
   48745             :    { (char *)"layerObj_moveClassUp", _wrap_layerObj_moveClassUp, METH_VARARGS, NULL},
   48746             :    { (char *)"layerObj_moveClassDown", _wrap_layerObj_moveClassDown, METH_VARARGS, NULL},
   48747             :    { (char *)"layerObj_setProcessingKey", _wrap_layerObj_setProcessingKey, METH_VARARGS, NULL},
   48748             :    { (char *)"layerObj_setProcessing", _wrap_layerObj_setProcessing, METH_VARARGS, NULL},
   48749             :    { (char *)"layerObj_addProcessing", _wrap_layerObj_addProcessing, METH_VARARGS, NULL},
   48750             :    { (char *)"layerObj_getProcessing", _wrap_layerObj_getProcessing, METH_VARARGS, NULL},
   48751             :    { (char *)"layerObj_getProcessingKey", _wrap_layerObj_getProcessingKey, METH_VARARGS, NULL},
   48752             :    { (char *)"layerObj_clearProcessing", _wrap_layerObj_clearProcessing, METH_VARARGS, NULL},
   48753             :    { (char *)"layerObj_setConnectionType", _wrap_layerObj_setConnectionType, METH_VARARGS, NULL},
   48754             :    { (char *)"layerObj_getClassIndex", _wrap_layerObj_getClassIndex, METH_VARARGS, NULL},
   48755             :    { (char *)"layerObj_getGeomTransform", _wrap_layerObj_getGeomTransform, METH_VARARGS, NULL},
   48756             :    { (char *)"layerObj_setGeomTransform", _wrap_layerObj_setGeomTransform, METH_VARARGS, NULL},
   48757             :    { (char *)"layerObj_getItemType", _wrap_layerObj_getItemType, METH_VARARGS, NULL},
   48758             :    { (char *)"layerObj_swigregister", layerObj_swigregister, METH_VARARGS, NULL},
   48759             :    { (char *)"mapObj_name_set", _wrap_mapObj_name_set, METH_VARARGS, NULL},
   48760             :    { (char *)"mapObj_name_get", _wrap_mapObj_name_get, METH_VARARGS, NULL},
   48761             :    { (char *)"mapObj_status_set", _wrap_mapObj_status_set, METH_VARARGS, NULL},
   48762             :    { (char *)"mapObj_status_get", _wrap_mapObj_status_get, METH_VARARGS, NULL},
   48763             :    { (char *)"mapObj_height_set", _wrap_mapObj_height_set, METH_VARARGS, NULL},
   48764             :    { (char *)"mapObj_height_get", _wrap_mapObj_height_get, METH_VARARGS, NULL},
   48765             :    { (char *)"mapObj_width_set", _wrap_mapObj_width_set, METH_VARARGS, NULL},
   48766             :    { (char *)"mapObj_width_get", _wrap_mapObj_width_get, METH_VARARGS, NULL},
   48767             :    { (char *)"mapObj_maxsize_set", _wrap_mapObj_maxsize_set, METH_VARARGS, NULL},
   48768             :    { (char *)"mapObj_maxsize_get", _wrap_mapObj_maxsize_get, METH_VARARGS, NULL},
   48769             :    { (char *)"mapObj_refcount_get", _wrap_mapObj_refcount_get, METH_VARARGS, NULL},
   48770             :    { (char *)"mapObj_numlayers_get", _wrap_mapObj_numlayers_get, METH_VARARGS, NULL},
   48771             :    { (char *)"mapObj_maxlayers_get", _wrap_mapObj_maxlayers_get, METH_VARARGS, NULL},
   48772             :    { (char *)"mapObj_symbolset_get", _wrap_mapObj_symbolset_get, METH_VARARGS, NULL},
   48773             :    { (char *)"mapObj_fontset_get", _wrap_mapObj_fontset_get, METH_VARARGS, NULL},
   48774             :    { (char *)"mapObj_labelcache_get", _wrap_mapObj_labelcache_get, METH_VARARGS, NULL},
   48775             :    { (char *)"mapObj_transparent_set", _wrap_mapObj_transparent_set, METH_VARARGS, NULL},
   48776             :    { (char *)"mapObj_transparent_get", _wrap_mapObj_transparent_get, METH_VARARGS, NULL},
   48777             :    { (char *)"mapObj_interlace_set", _wrap_mapObj_interlace_set, METH_VARARGS, NULL},
   48778             :    { (char *)"mapObj_interlace_get", _wrap_mapObj_interlace_get, METH_VARARGS, NULL},
   48779             :    { (char *)"mapObj_imagequality_set", _wrap_mapObj_imagequality_set, METH_VARARGS, NULL},
   48780             :    { (char *)"mapObj_imagequality_get", _wrap_mapObj_imagequality_get, METH_VARARGS, NULL},
   48781             :    { (char *)"mapObj_extent_set", _wrap_mapObj_extent_set, METH_VARARGS, NULL},
   48782             :    { (char *)"mapObj_extent_get", _wrap_mapObj_extent_get, METH_VARARGS, NULL},
   48783             :    { (char *)"mapObj_cellsize_set", _wrap_mapObj_cellsize_set, METH_VARARGS, NULL},
   48784             :    { (char *)"mapObj_cellsize_get", _wrap_mapObj_cellsize_get, METH_VARARGS, NULL},
   48785             :    { (char *)"mapObj_units_set", _wrap_mapObj_units_set, METH_VARARGS, NULL},
   48786             :    { (char *)"mapObj_units_get", _wrap_mapObj_units_get, METH_VARARGS, NULL},
   48787             :    { (char *)"mapObj_scaledenom_set", _wrap_mapObj_scaledenom_set, METH_VARARGS, NULL},
   48788             :    { (char *)"mapObj_scaledenom_get", _wrap_mapObj_scaledenom_get, METH_VARARGS, NULL},
   48789             :    { (char *)"mapObj_resolution_set", _wrap_mapObj_resolution_set, METH_VARARGS, NULL},
   48790             :    { (char *)"mapObj_resolution_get", _wrap_mapObj_resolution_get, METH_VARARGS, NULL},
   48791             :    { (char *)"mapObj_defresolution_set", _wrap_mapObj_defresolution_set, METH_VARARGS, NULL},
   48792             :    { (char *)"mapObj_defresolution_get", _wrap_mapObj_defresolution_get, METH_VARARGS, NULL},
   48793             :    { (char *)"mapObj_shapepath_set", _wrap_mapObj_shapepath_set, METH_VARARGS, NULL},
   48794             :    { (char *)"mapObj_shapepath_get", _wrap_mapObj_shapepath_get, METH_VARARGS, NULL},
   48795             :    { (char *)"mapObj_mappath_set", _wrap_mapObj_mappath_set, METH_VARARGS, NULL},
   48796             :    { (char *)"mapObj_mappath_get", _wrap_mapObj_mappath_get, METH_VARARGS, NULL},
   48797             :    { (char *)"mapObj_sldurl_set", _wrap_mapObj_sldurl_set, METH_VARARGS, NULL},
   48798             :    { (char *)"mapObj_sldurl_get", _wrap_mapObj_sldurl_get, METH_VARARGS, NULL},
   48799             :    { (char *)"mapObj_imagecolor_set", _wrap_mapObj_imagecolor_set, METH_VARARGS, NULL},
   48800             :    { (char *)"mapObj_imagecolor_get", _wrap_mapObj_imagecolor_get, METH_VARARGS, NULL},
   48801             :    { (char *)"mapObj_numoutputformats_get", _wrap_mapObj_numoutputformats_get, METH_VARARGS, NULL},
   48802             :    { (char *)"mapObj_outputformat_get", _wrap_mapObj_outputformat_get, METH_VARARGS, NULL},
   48803             :    { (char *)"mapObj_imagetype_get", _wrap_mapObj_imagetype_get, METH_VARARGS, NULL},
   48804             :    { (char *)"mapObj_reference_get", _wrap_mapObj_reference_get, METH_VARARGS, NULL},
   48805             :    { (char *)"mapObj_scalebar_get", _wrap_mapObj_scalebar_get, METH_VARARGS, NULL},
   48806             :    { (char *)"mapObj_legend_get", _wrap_mapObj_legend_get, METH_VARARGS, NULL},
   48807             :    { (char *)"mapObj_querymap_get", _wrap_mapObj_querymap_get, METH_VARARGS, NULL},
   48808             :    { (char *)"mapObj_web_get", _wrap_mapObj_web_get, METH_VARARGS, NULL},
   48809             :    { (char *)"mapObj_layerorder_set", _wrap_mapObj_layerorder_set, METH_VARARGS, NULL},
   48810             :    { (char *)"mapObj_layerorder_get", _wrap_mapObj_layerorder_get, METH_VARARGS, NULL},
   48811             :    { (char *)"mapObj_debug_set", _wrap_mapObj_debug_set, METH_VARARGS, NULL},
   48812             :    { (char *)"mapObj_debug_get", _wrap_mapObj_debug_get, METH_VARARGS, NULL},
   48813             :    { (char *)"mapObj_datapattern_set", _wrap_mapObj_datapattern_set, METH_VARARGS, NULL},
   48814             :    { (char *)"mapObj_datapattern_get", _wrap_mapObj_datapattern_get, METH_VARARGS, NULL},
   48815             :    { (char *)"mapObj_templatepattern_set", _wrap_mapObj_templatepattern_set, METH_VARARGS, NULL},
   48816             :    { (char *)"mapObj_templatepattern_get", _wrap_mapObj_templatepattern_get, METH_VARARGS, NULL},
   48817             :    { (char *)"mapObj_configoptions_get", _wrap_mapObj_configoptions_get, METH_VARARGS, NULL},
   48818             :    { (char *)"new_mapObj", _wrap_new_mapObj, METH_VARARGS, NULL},
   48819             :    { (char *)"delete_mapObj", _wrap_delete_mapObj, METH_VARARGS, NULL},
   48820             :    { (char *)"mapObj_clone", _wrap_mapObj_clone, METH_VARARGS, NULL},
   48821             :    { (char *)"mapObj_insertLayer", _wrap_mapObj_insertLayer, METH_VARARGS, NULL},
   48822             :    { (char *)"mapObj_removeLayer", _wrap_mapObj_removeLayer, METH_VARARGS, NULL},
   48823             :    { (char *)"mapObj_setExtent", _wrap_mapObj_setExtent, METH_VARARGS, NULL},
   48824             :    { (char *)"mapObj_offsetExtent", _wrap_mapObj_offsetExtent, METH_VARARGS, NULL},
   48825             :    { (char *)"mapObj_scaleExtent", _wrap_mapObj_scaleExtent, METH_VARARGS, NULL},
   48826             :    { (char *)"mapObj_setCenter", _wrap_mapObj_setCenter, METH_VARARGS, NULL},
   48827             :    { (char *)"mapObj_setSize", _wrap_mapObj_setSize, METH_VARARGS, NULL},
   48828             :    { (char *)"mapObj_pixelToGeoref", _wrap_mapObj_pixelToGeoref, METH_VARARGS, NULL},
   48829             :    { (char *)"mapObj_getRotation", _wrap_mapObj_getRotation, METH_VARARGS, NULL},
   48830             :    { (char *)"mapObj_setRotation", _wrap_mapObj_setRotation, METH_VARARGS, NULL},
   48831             :    { (char *)"mapObj_getLayer", _wrap_mapObj_getLayer, METH_VARARGS, NULL},
   48832             :    { (char *)"mapObj_getLayerByName", _wrap_mapObj_getLayerByName, METH_VARARGS, NULL},
   48833             :    { (char *)"mapObj_getSymbolByName", _wrap_mapObj_getSymbolByName, METH_VARARGS, NULL},
   48834             :    { (char *)"mapObj_prepareQuery", _wrap_mapObj_prepareQuery, METH_VARARGS, NULL},
   48835             :    { (char *)"mapObj_prepareImage", _wrap_mapObj_prepareImage, METH_VARARGS, NULL},
   48836             :    { (char *)"mapObj_setImageType", _wrap_mapObj_setImageType, METH_VARARGS, NULL},
   48837             :    { (char *)"mapObj_selectOutputFormat", _wrap_mapObj_selectOutputFormat, METH_VARARGS, NULL},
   48838             :    { (char *)"mapObj_getOutputFormat", _wrap_mapObj_getOutputFormat, METH_VARARGS, NULL},
   48839             :    { (char *)"mapObj_setOutputFormat", _wrap_mapObj_setOutputFormat, METH_VARARGS, NULL},
   48840             :    { (char *)"mapObj_draw", _wrap_mapObj_draw, METH_VARARGS, NULL},
   48841             :    { (char *)"mapObj_drawQuery", _wrap_mapObj_drawQuery, METH_VARARGS, NULL},
   48842             :    { (char *)"mapObj_drawLegend", _wrap_mapObj_drawLegend, METH_VARARGS, NULL},
   48843             :    { (char *)"mapObj_drawScalebar", _wrap_mapObj_drawScalebar, METH_VARARGS, NULL},
   48844             :    { (char *)"mapObj_drawReferenceMap", _wrap_mapObj_drawReferenceMap, METH_VARARGS, NULL},
   48845             :    { (char *)"mapObj_embedScalebar", _wrap_mapObj_embedScalebar, METH_VARARGS, NULL},
   48846             :    { (char *)"mapObj_embedLegend", _wrap_mapObj_embedLegend, METH_VARARGS, NULL},
   48847             :    { (char *)"mapObj_drawLabelCache", _wrap_mapObj_drawLabelCache, METH_VARARGS, NULL},
   48848             :    { (char *)"mapObj_queryByFilter", _wrap_mapObj_queryByFilter, METH_VARARGS, NULL},
   48849             :    { (char *)"mapObj_queryByPoint", _wrap_mapObj_queryByPoint, METH_VARARGS, NULL},
   48850             :    { (char *)"mapObj_queryByRect", _wrap_mapObj_queryByRect, METH_VARARGS, NULL},
   48851             :    { (char *)"mapObj_queryByFeatures", _wrap_mapObj_queryByFeatures, METH_VARARGS, NULL},
   48852             :    { (char *)"mapObj_queryByShape", _wrap_mapObj_queryByShape, METH_VARARGS, NULL},
   48853             :    { (char *)"mapObj_setWKTProjection", _wrap_mapObj_setWKTProjection, METH_VARARGS, NULL},
   48854             :    { (char *)"mapObj_getProjection", _wrap_mapObj_getProjection, METH_VARARGS, NULL},
   48855             :    { (char *)"mapObj_setProjection", _wrap_mapObj_setProjection, METH_VARARGS, NULL},
   48856             :    { (char *)"mapObj_save", _wrap_mapObj_save, METH_VARARGS, NULL},
   48857             :    { (char *)"mapObj_saveQuery", _wrap_mapObj_saveQuery, METH_VARARGS, NULL},
   48858             :    { (char *)"mapObj_loadQuery", _wrap_mapObj_loadQuery, METH_VARARGS, NULL},
   48859             :    { (char *)"mapObj_freeQuery", _wrap_mapObj_freeQuery, METH_VARARGS, NULL},
   48860             :    { (char *)"mapObj_saveQueryAsGML", _wrap_mapObj_saveQueryAsGML, METH_VARARGS, NULL},
   48861             :    { (char *)"mapObj_getMetaData", _wrap_mapObj_getMetaData, METH_VARARGS, NULL},
   48862             :    { (char *)"mapObj_setMetaData", _wrap_mapObj_setMetaData, METH_VARARGS, NULL},
   48863             :    { (char *)"mapObj_removeMetaData", _wrap_mapObj_removeMetaData, METH_VARARGS, NULL},
   48864             :    { (char *)"mapObj_getFirstMetaDataKey", _wrap_mapObj_getFirstMetaDataKey, METH_VARARGS, NULL},
   48865             :    { (char *)"mapObj_getNextMetaDataKey", _wrap_mapObj_getNextMetaDataKey, METH_VARARGS, NULL},
   48866             :    { (char *)"mapObj_setSymbolSet", _wrap_mapObj_setSymbolSet, METH_VARARGS, NULL},
   48867             :    { (char *)"mapObj_getNumSymbols", _wrap_mapObj_getNumSymbols, METH_VARARGS, NULL},
   48868             :    { (char *)"mapObj_setFontSet", _wrap_mapObj_setFontSet, METH_VARARGS, NULL},
   48869             :    { (char *)"mapObj_saveMapContext", _wrap_mapObj_saveMapContext, METH_VARARGS, NULL},
   48870             :    { (char *)"mapObj_loadMapContext", _wrap_mapObj_loadMapContext, METH_VARARGS, NULL},
   48871             :    { (char *)"mapObj_moveLayerUp", _wrap_mapObj_moveLayerUp, METH_VARARGS, NULL},
   48872             :    { (char *)"mapObj_moveLayerDown", _wrap_mapObj_moveLayerDown, METH_VARARGS, NULL},
   48873             :    { (char *)"mapObj_getLayersDrawingOrder", _wrap_mapObj_getLayersDrawingOrder, METH_VARARGS, NULL},
   48874             :    { (char *)"mapObj_setLayersDrawingOrder", _wrap_mapObj_setLayersDrawingOrder, METH_VARARGS, NULL},
   48875             :    { (char *)"mapObj_setConfigOption", _wrap_mapObj_setConfigOption, METH_VARARGS, NULL},
   48876             :    { (char *)"mapObj_getConfigOption", _wrap_mapObj_getConfigOption, METH_VARARGS, NULL},
   48877             :    { (char *)"mapObj_applyConfigOptions", _wrap_mapObj_applyConfigOptions, METH_VARARGS, NULL},
   48878             :    { (char *)"mapObj_applySLD", _wrap_mapObj_applySLD, METH_VARARGS, NULL},
   48879             :    { (char *)"mapObj_applySLDURL", _wrap_mapObj_applySLDURL, METH_VARARGS, NULL},
   48880             :    { (char *)"mapObj_generateSLD", _wrap_mapObj_generateSLD, METH_VARARGS, NULL},
   48881             :    { (char *)"mapObj_processTemplate", _wrap_mapObj_processTemplate, METH_VARARGS, NULL},
   48882             :    { (char *)"mapObj_processLegendTemplate", _wrap_mapObj_processLegendTemplate, METH_VARARGS, NULL},
   48883             :    { (char *)"mapObj_processQueryTemplate", _wrap_mapObj_processQueryTemplate, METH_VARARGS, NULL},
   48884             :    { (char *)"mapObj_getOutputFormatByName", _wrap_mapObj_getOutputFormatByName, METH_VARARGS, NULL},
   48885             :    { (char *)"mapObj_appendOutputFormat", _wrap_mapObj_appendOutputFormat, METH_VARARGS, NULL},
   48886             :    { (char *)"mapObj_removeOutputFormat", _wrap_mapObj_removeOutputFormat, METH_VARARGS, NULL},
   48887             :    { (char *)"mapObj_loadOWSParameters", _wrap_mapObj_loadOWSParameters, METH_VARARGS, NULL},
   48888             :    { (char *)"mapObj_OWSDispatch", _wrap_mapObj_OWSDispatch, METH_VARARGS, NULL},
   48889             :    { (char *)"mapObj_convertToString", _wrap_mapObj_convertToString, METH_VARARGS, NULL},
   48890             :    { (char *)"mapObj_applyDefaultSubstitutions", _wrap_mapObj_applyDefaultSubstitutions, METH_VARARGS, NULL},
   48891             :    { (char *)"mapObj_applySubstitutions", _wrap_mapObj_applySubstitutions, METH_VARARGS, NULL},
   48892             :    { (char *)"mapObj_zoomPoint", _wrap_mapObj_zoomPoint, METH_VARARGS, NULL},
   48893             :    { (char *)"mapObj_zoomRectangle", _wrap_mapObj_zoomRectangle, METH_VARARGS, NULL},
   48894             :    { (char *)"mapObj_zoomScale", _wrap_mapObj_zoomScale, METH_VARARGS, NULL},
   48895             :    { (char *)"mapObj_getLayerOrder", _wrap_mapObj_getLayerOrder, METH_VARARGS, NULL},
   48896             :    { (char *)"mapObj_setLayerOrder", _wrap_mapObj_setLayerOrder, METH_VARARGS, NULL},
   48897             :    { (char *)"mapObj_getSize", _wrap_mapObj_getSize, METH_VARARGS, NULL},
   48898             :    { (char *)"mapObj_swigregister", mapObj_swigregister, METH_VARARGS, NULL},
   48899             :    { (char *)"msSaveImage", _wrap_msSaveImage, METH_VARARGS, NULL},
   48900             :    { (char *)"msFreeImage", _wrap_msFreeImage, METH_VARARGS, NULL},
   48901             :    { (char *)"msSetup", _wrap_msSetup, METH_VARARGS, NULL},
   48902             :    { (char *)"msCleanup", _wrap_msCleanup, METH_VARARGS, NULL},
   48903             :    { (char *)"msLoadMapFromString", _wrap_msLoadMapFromString, METH_VARARGS, NULL},
   48904             :    { (char *)"rectObj_minx_set", _wrap_rectObj_minx_set, METH_VARARGS, NULL},
   48905             :    { (char *)"rectObj_minx_get", _wrap_rectObj_minx_get, METH_VARARGS, NULL},
   48906             :    { (char *)"rectObj_miny_set", _wrap_rectObj_miny_set, METH_VARARGS, NULL},
   48907             :    { (char *)"rectObj_miny_get", _wrap_rectObj_miny_get, METH_VARARGS, NULL},
   48908             :    { (char *)"rectObj_maxx_set", _wrap_rectObj_maxx_set, METH_VARARGS, NULL},
   48909             :    { (char *)"rectObj_maxx_get", _wrap_rectObj_maxx_get, METH_VARARGS, NULL},
   48910             :    { (char *)"rectObj_maxy_set", _wrap_rectObj_maxy_set, METH_VARARGS, NULL},
   48911             :    { (char *)"rectObj_maxy_get", _wrap_rectObj_maxy_get, METH_VARARGS, NULL},
   48912             :    { (char *)"new_rectObj", _wrap_new_rectObj, METH_VARARGS, NULL},
   48913             :    { (char *)"delete_rectObj", _wrap_delete_rectObj, METH_VARARGS, NULL},
   48914             :    { (char *)"rectObj_project", _wrap_rectObj_project, METH_VARARGS, NULL},
   48915             :    { (char *)"rectObj_fit", _wrap_rectObj_fit, METH_VARARGS, NULL},
   48916             :    { (char *)"rectObj_draw", _wrap_rectObj_draw, METH_VARARGS, NULL},
   48917             :    { (char *)"rectObj_getCenter", _wrap_rectObj_getCenter, METH_VARARGS, NULL},
   48918             :    { (char *)"rectObj_toPolygon", _wrap_rectObj_toPolygon, METH_VARARGS, NULL},
   48919             :    { (char *)"rectObj_toString", _wrap_rectObj_toString, METH_VARARGS, NULL},
   48920             :    { (char *)"rectObj_swigregister", rectObj_swigregister, METH_VARARGS, NULL},
   48921             :    { (char *)"pointObj_x_set", _wrap_pointObj_x_set, METH_VARARGS, NULL},
   48922             :    { (char *)"pointObj_x_get", _wrap_pointObj_x_get, METH_VARARGS, NULL},
   48923             :    { (char *)"pointObj_y_set", _wrap_pointObj_y_set, METH_VARARGS, NULL},
   48924             :    { (char *)"pointObj_y_get", _wrap_pointObj_y_get, METH_VARARGS, NULL},
   48925             :    { (char *)"new_pointObj", _wrap_new_pointObj, METH_VARARGS, NULL},
   48926             :    { (char *)"delete_pointObj", _wrap_delete_pointObj, METH_VARARGS, NULL},
   48927             :    { (char *)"pointObj_project", _wrap_pointObj_project, METH_VARARGS, NULL},
   48928             :    { (char *)"pointObj_draw", _wrap_pointObj_draw, METH_VARARGS, NULL},
   48929             :    { (char *)"pointObj_distanceToPoint", _wrap_pointObj_distanceToPoint, METH_VARARGS, NULL},
   48930             :    { (char *)"pointObj_distanceToSegment", _wrap_pointObj_distanceToSegment, METH_VARARGS, NULL},
   48931             :    { (char *)"pointObj_distanceToShape", _wrap_pointObj_distanceToShape, METH_VARARGS, NULL},
   48932             :    { (char *)"pointObj_setXY", _wrap_pointObj_setXY, METH_VARARGS, NULL},
   48933             :    { (char *)"pointObj_setXYZ", _wrap_pointObj_setXYZ, METH_VARARGS, NULL},
   48934             :    { (char *)"pointObj_setXYZM", _wrap_pointObj_setXYZM, METH_VARARGS, NULL},
   48935             :    { (char *)"pointObj_toString", _wrap_pointObj_toString, METH_VARARGS, NULL},
   48936             :    { (char *)"pointObj_toShape", _wrap_pointObj_toShape, METH_VARARGS, NULL},
   48937             :    { (char *)"pointObj_swigregister", pointObj_swigregister, METH_VARARGS, NULL},
   48938             :    { (char *)"lineObj_numpoints_get", _wrap_lineObj_numpoints_get, METH_VARARGS, NULL},
   48939             :    { (char *)"new_lineObj", _wrap_new_lineObj, METH_VARARGS, NULL},
   48940             :    { (char *)"delete_lineObj", _wrap_delete_lineObj, METH_VARARGS, NULL},
   48941             :    { (char *)"lineObj_project", _wrap_lineObj_project, METH_VARARGS, NULL},
   48942             :    { (char *)"lineObj_get", _wrap_lineObj_get, METH_VARARGS, NULL},
   48943             :    { (char *)"lineObj_add", _wrap_lineObj_add, METH_VARARGS, NULL},
   48944             :    { (char *)"lineObj_set", _wrap_lineObj_set, METH_VARARGS, NULL},
   48945             :    { (char *)"lineObj_swigregister", lineObj_swigregister, METH_VARARGS, NULL},
   48946             :    { (char *)"shapeObj_numlines_get", _wrap_shapeObj_numlines_get, METH_VARARGS, NULL},
   48947             :    { (char *)"shapeObj_numvalues_get", _wrap_shapeObj_numvalues_get, METH_VARARGS, NULL},
   48948             :    { (char *)"shapeObj_bounds_set", _wrap_shapeObj_bounds_set, METH_VARARGS, NULL},
   48949             :    { (char *)"shapeObj_bounds_get", _wrap_shapeObj_bounds_get, METH_VARARGS, NULL},
   48950             :    { (char *)"shapeObj_type_set", _wrap_shapeObj_type_set, METH_VARARGS, NULL},
   48951             :    { (char *)"shapeObj_type_get", _wrap_shapeObj_type_get, METH_VARARGS, NULL},
   48952             :    { (char *)"shapeObj_index_set", _wrap_shapeObj_index_set, METH_VARARGS, NULL},
   48953             :    { (char *)"shapeObj_index_get", _wrap_shapeObj_index_get, METH_VARARGS, NULL},
   48954             :    { (char *)"shapeObj_tileindex_set", _wrap_shapeObj_tileindex_set, METH_VARARGS, NULL},
   48955             :    { (char *)"shapeObj_tileindex_get", _wrap_shapeObj_tileindex_get, METH_VARARGS, NULL},
   48956             :    { (char *)"shapeObj_classindex_set", _wrap_shapeObj_classindex_set, METH_VARARGS, NULL},
   48957             :    { (char *)"shapeObj_classindex_get", _wrap_shapeObj_classindex_get, METH_VARARGS, NULL},
   48958             :    { (char *)"shapeObj_text_set", _wrap_shapeObj_text_set, METH_VARARGS, NULL},
   48959             :    { (char *)"shapeObj_text_get", _wrap_shapeObj_text_get, METH_VARARGS, NULL},
   48960             :    { (char *)"shapeObj_scratch_set", _wrap_shapeObj_scratch_set, METH_VARARGS, NULL},
   48961             :    { (char *)"shapeObj_scratch_get", _wrap_shapeObj_scratch_get, METH_VARARGS, NULL},
   48962             :    { (char *)"shapeObj_resultindex_set", _wrap_shapeObj_resultindex_set, METH_VARARGS, NULL},
   48963             :    { (char *)"shapeObj_resultindex_get", _wrap_shapeObj_resultindex_get, METH_VARARGS, NULL},
   48964             :    { (char *)"new_shapeObj", _wrap_new_shapeObj, METH_VARARGS, NULL},
   48965             :    { (char *)"delete_shapeObj", _wrap_delete_shapeObj, METH_VARARGS, NULL},
   48966             :    { (char *)"shapeObj_fromWKT", _wrap_shapeObj_fromWKT, METH_VARARGS, NULL},
   48967             :    { (char *)"shapeObj_project", _wrap_shapeObj_project, METH_VARARGS, NULL},
   48968             :    { (char *)"shapeObj_get", _wrap_shapeObj_get, METH_VARARGS, NULL},
   48969             :    { (char *)"shapeObj_add", _wrap_shapeObj_add, METH_VARARGS, NULL},
   48970             :    { (char *)"shapeObj_draw", _wrap_shapeObj_draw, METH_VARARGS, NULL},
   48971             :    { (char *)"shapeObj_setBounds", _wrap_shapeObj_setBounds, METH_VARARGS, NULL},
   48972             :    { (char *)"shapeObj_clone", _wrap_shapeObj_clone, METH_VARARGS, NULL},
   48973             :    { (char *)"shapeObj_copy", _wrap_shapeObj_copy, METH_VARARGS, NULL},
   48974             :    { (char *)"shapeObj_toWKT", _wrap_shapeObj_toWKT, METH_VARARGS, NULL},
   48975             :    { (char *)"shapeObj_buffer", _wrap_shapeObj_buffer, METH_VARARGS, NULL},
   48976             :    { (char *)"shapeObj_simplify", _wrap_shapeObj_simplify, METH_VARARGS, NULL},
   48977             :    { (char *)"shapeObj_topologyPreservingSimplify", _wrap_shapeObj_topologyPreservingSimplify, METH_VARARGS, NULL},
   48978             :    { (char *)"shapeObj_convexHull", _wrap_shapeObj_convexHull, METH_VARARGS, NULL},
   48979             :    { (char *)"shapeObj_boundary", _wrap_shapeObj_boundary, METH_VARARGS, NULL},
   48980             :    { (char *)"shapeObj_getCentroid", _wrap_shapeObj_getCentroid, METH_VARARGS, NULL},
   48981             :    { (char *)"shapeObj_Union", _wrap_shapeObj_Union, METH_VARARGS, NULL},
   48982             :    { (char *)"shapeObj_intersection", _wrap_shapeObj_intersection, METH_VARARGS, NULL},
   48983             :    { (char *)"shapeObj_difference", _wrap_shapeObj_difference, METH_VARARGS, NULL},
   48984             :    { (char *)"shapeObj_symDifference", _wrap_shapeObj_symDifference, METH_VARARGS, NULL},
   48985             :    { (char *)"shapeObj_overlaps", _wrap_shapeObj_overlaps, METH_VARARGS, NULL},
   48986             :    { (char *)"shapeObj_within", _wrap_shapeObj_within, METH_VARARGS, NULL},
   48987             :    { (char *)"shapeObj_crosses", _wrap_shapeObj_crosses, METH_VARARGS, NULL},
   48988             :    { (char *)"shapeObj_intersects", _wrap_shapeObj_intersects, METH_VARARGS, NULL},
   48989             :    { (char *)"shapeObj_touches", _wrap_shapeObj_touches, METH_VARARGS, NULL},
   48990             :    { (char *)"shapeObj_equals", _wrap_shapeObj_equals, METH_VARARGS, NULL},
   48991             :    { (char *)"shapeObj_disjoint", _wrap_shapeObj_disjoint, METH_VARARGS, NULL},
   48992             :    { (char *)"shapeObj_getArea", _wrap_shapeObj_getArea, METH_VARARGS, NULL},
   48993             :    { (char *)"shapeObj_getLength", _wrap_shapeObj_getLength, METH_VARARGS, NULL},
   48994             :    { (char *)"shapeObj_getValue", _wrap_shapeObj_getValue, METH_VARARGS, NULL},
   48995             :    { (char *)"shapeObj_contains", _wrap_shapeObj_contains, METH_VARARGS, NULL},
   48996             :    { (char *)"shapeObj_distanceToPoint", _wrap_shapeObj_distanceToPoint, METH_VARARGS, NULL},
   48997             :    { (char *)"shapeObj_distanceToShape", _wrap_shapeObj_distanceToShape, METH_VARARGS, NULL},
   48998             :    { (char *)"shapeObj_getLabelPoint", _wrap_shapeObj_getLabelPoint, METH_VARARGS, NULL},
   48999             :    { (char *)"shapeObj_setValue", _wrap_shapeObj_setValue, METH_VARARGS, NULL},
   49000             :    { (char *)"shapeObj_initValues", _wrap_shapeObj_initValues, METH_VARARGS, NULL},
   49001             :    { (char *)"shapeObj_swigregister", shapeObj_swigregister, METH_VARARGS, NULL},
   49002             :    { (char *)"errorObj_code_set", _wrap_errorObj_code_set, METH_VARARGS, NULL},
   49003             :    { (char *)"errorObj_code_get", _wrap_errorObj_code_get, METH_VARARGS, NULL},
   49004             :    { (char *)"errorObj_routine_set", _wrap_errorObj_routine_set, METH_VARARGS, NULL},
   49005             :    { (char *)"errorObj_routine_get", _wrap_errorObj_routine_get, METH_VARARGS, NULL},
   49006             :    { (char *)"errorObj_message_set", _wrap_errorObj_message_set, METH_VARARGS, NULL},
   49007             :    { (char *)"errorObj_message_get", _wrap_errorObj_message_get, METH_VARARGS, NULL},
   49008             :    { (char *)"errorObj_isreported_set", _wrap_errorObj_isreported_set, METH_VARARGS, NULL},
   49009             :    { (char *)"errorObj_isreported_get", _wrap_errorObj_isreported_get, METH_VARARGS, NULL},
   49010             :    { (char *)"errorObj_errorcount_set", _wrap_errorObj_errorcount_set, METH_VARARGS, NULL},
   49011             :    { (char *)"errorObj_errorcount_get", _wrap_errorObj_errorcount_get, METH_VARARGS, NULL},
   49012             :    { (char *)"new_errorObj", _wrap_new_errorObj, METH_VARARGS, NULL},
   49013             :    { (char *)"delete_errorObj", _wrap_delete_errorObj, METH_VARARGS, NULL},
   49014             :    { (char *)"errorObj_next", _wrap_errorObj_next, METH_VARARGS, NULL},
   49015             :    { (char *)"errorObj_swigregister", errorObj_swigregister, METH_VARARGS, NULL},
   49016             :    { (char *)"msGetErrorObj", _wrap_msGetErrorObj, METH_VARARGS, NULL},
   49017             :    { (char *)"msResetErrorList", _wrap_msResetErrorList, METH_VARARGS, NULL},
   49018             :    { (char *)"msGetVersion", _wrap_msGetVersion, METH_VARARGS, NULL},
   49019             :    { (char *)"msGetVersionInt", _wrap_msGetVersionInt, METH_VARARGS, NULL},
   49020             :    { (char *)"msGetErrorString", _wrap_msGetErrorString, METH_VARARGS, NULL},
   49021             :    { (char *)"DBFInfo_nRecords_get", _wrap_DBFInfo_nRecords_get, METH_VARARGS, NULL},
   49022             :    { (char *)"DBFInfo_nFields_get", _wrap_DBFInfo_nFields_get, METH_VARARGS, NULL},
   49023             :    { (char *)"DBFInfo_getFieldName", _wrap_DBFInfo_getFieldName, METH_VARARGS, NULL},
   49024             :    { (char *)"DBFInfo_getFieldWidth", _wrap_DBFInfo_getFieldWidth, METH_VARARGS, NULL},
   49025             :    { (char *)"DBFInfo_getFieldDecimals", _wrap_DBFInfo_getFieldDecimals, METH_VARARGS, NULL},
   49026             :    { (char *)"DBFInfo_getFieldType", _wrap_DBFInfo_getFieldType, METH_VARARGS, NULL},
   49027             :    { (char *)"new_DBFInfo", _wrap_new_DBFInfo, METH_VARARGS, NULL},
   49028             :    { (char *)"delete_DBFInfo", _wrap_delete_DBFInfo, METH_VARARGS, NULL},
   49029             :    { (char *)"DBFInfo_swigregister", DBFInfo_swigregister, METH_VARARGS, NULL},
   49030             :    { (char *)"shapefileObj_type_get", _wrap_shapefileObj_type_get, METH_VARARGS, NULL},
   49031             :    { (char *)"shapefileObj_numshapes_get", _wrap_shapefileObj_numshapes_get, METH_VARARGS, NULL},
   49032             :    { (char *)"shapefileObj_bounds_get", _wrap_shapefileObj_bounds_get, METH_VARARGS, NULL},
   49033             :    { (char *)"new_shapefileObj", _wrap_new_shapefileObj, METH_VARARGS, NULL},
   49034             :    { (char *)"delete_shapefileObj", _wrap_delete_shapefileObj, METH_VARARGS, NULL},
   49035             :    { (char *)"shapefileObj_get", _wrap_shapefileObj_get, METH_VARARGS, NULL},
   49036             :    { (char *)"shapefileObj_getShape", _wrap_shapefileObj_getShape, METH_VARARGS, NULL},
   49037             :    { (char *)"shapefileObj_getPoint", _wrap_shapefileObj_getPoint, METH_VARARGS, NULL},
   49038             :    { (char *)"shapefileObj_getTransformed", _wrap_shapefileObj_getTransformed, METH_VARARGS, NULL},
   49039             :    { (char *)"shapefileObj_getExtent", _wrap_shapefileObj_getExtent, METH_VARARGS, NULL},
   49040             :    { (char *)"shapefileObj_add", _wrap_shapefileObj_add, METH_VARARGS, NULL},
   49041             :    { (char *)"shapefileObj_addPoint", _wrap_shapefileObj_addPoint, METH_VARARGS, NULL},
   49042             :    { (char *)"shapefileObj_getDBF", _wrap_shapefileObj_getDBF, METH_VARARGS, NULL},
   49043             :    { (char *)"shapefileObj_swigregister", shapefileObj_swigregister, METH_VARARGS, NULL},
   49044             :    { (char *)"projectionObj_numargs_get", _wrap_projectionObj_numargs_get, METH_VARARGS, NULL},
   49045             :    { (char *)"projectionObj_automatic_get", _wrap_projectionObj_automatic_get, METH_VARARGS, NULL},
   49046             :    { (char *)"projectionObj_wellknownprojection_set", _wrap_projectionObj_wellknownprojection_set, METH_VARARGS, NULL},
   49047             :    { (char *)"projectionObj_wellknownprojection_get", _wrap_projectionObj_wellknownprojection_get, METH_VARARGS, NULL},
   49048             :    { (char *)"new_projectionObj", _wrap_new_projectionObj, METH_VARARGS, NULL},
   49049             :    { (char *)"delete_projectionObj", _wrap_delete_projectionObj, METH_VARARGS, NULL},
   49050             :    { (char *)"projectionObj_setWKTProjection", _wrap_projectionObj_setWKTProjection, METH_VARARGS, NULL},
   49051             :    { (char *)"projectionObj_getUnits", _wrap_projectionObj_getUnits, METH_VARARGS, NULL},
   49052             :    { (char *)"projectionObj_swigregister", projectionObj_swigregister, METH_VARARGS, NULL},
   49053             :    { (char *)"colorObj_red_set", _wrap_colorObj_red_set, METH_VARARGS, (char *)"Red component of color in range [0-255]"},
   49054             :    { (char *)"colorObj_red_get", _wrap_colorObj_red_get, METH_VARARGS, (char *)"Red component of color in range [0-255]"},
   49055             :    { (char *)"colorObj_green_set", _wrap_colorObj_green_set, METH_VARARGS, (char *)"Green component of color in range [0-255]"},
   49056             :    { (char *)"colorObj_green_get", _wrap_colorObj_green_get, METH_VARARGS, (char *)"Green component of color in range [0-255]"},
   49057             :    { (char *)"colorObj_blue_set", _wrap_colorObj_blue_set, METH_VARARGS, (char *)"Blue component of color in range [0-255]"},
   49058             :    { (char *)"colorObj_blue_get", _wrap_colorObj_blue_get, METH_VARARGS, (char *)"Blue component of color in range [0-255]"},
   49059             :    { (char *)"colorObj_alpha_set", _wrap_colorObj_alpha_set, METH_VARARGS, (char *)"Alpha (opacity) component of color in range [0-255]"},
   49060             :    { (char *)"colorObj_alpha_get", _wrap_colorObj_alpha_get, METH_VARARGS, (char *)"Alpha (opacity) component of color in range [0-255]"},
   49061             :    { (char *)"new_colorObj", _wrap_new_colorObj, METH_VARARGS, (char *)"An object representing a color."},
   49062             :    { (char *)"delete_colorObj", _wrap_delete_colorObj, METH_VARARGS, NULL},
   49063             :    { (char *)"colorObj_setRGB", _wrap_colorObj_setRGB, METH_VARARGS, NULL},
   49064             :    { (char *)"colorObj_setHex", _wrap_colorObj_setHex, METH_VARARGS, NULL},
   49065             :    { (char *)"colorObj_toHex", _wrap_colorObj_toHex, METH_VARARGS, NULL},
   49066             :    { (char *)"colorObj_swigregister", colorObj_swigregister, METH_VARARGS, NULL},
   49067             :    { (char *)"symbolObj_name_set", _wrap_symbolObj_name_set, METH_VARARGS, NULL},
   49068             :    { (char *)"symbolObj_name_get", _wrap_symbolObj_name_get, METH_VARARGS, NULL},
   49069             :    { (char *)"symbolObj_type_set", _wrap_symbolObj_type_set, METH_VARARGS, NULL},
   49070             :    { (char *)"symbolObj_type_get", _wrap_symbolObj_type_get, METH_VARARGS, NULL},
   49071             :    { (char *)"symbolObj_inmapfile_set", _wrap_symbolObj_inmapfile_set, METH_VARARGS, NULL},
   49072             :    { (char *)"symbolObj_inmapfile_get", _wrap_symbolObj_inmapfile_get, METH_VARARGS, NULL},
   49073             :    { (char *)"symbolObj_sizex_set", _wrap_symbolObj_sizex_set, METH_VARARGS, NULL},
   49074             :    { (char *)"symbolObj_sizex_get", _wrap_symbolObj_sizex_get, METH_VARARGS, NULL},
   49075             :    { (char *)"symbolObj_sizey_set", _wrap_symbolObj_sizey_set, METH_VARARGS, NULL},
   49076             :    { (char *)"symbolObj_sizey_get", _wrap_symbolObj_sizey_get, METH_VARARGS, NULL},
   49077             :    { (char *)"symbolObj_minx_set", _wrap_symbolObj_minx_set, METH_VARARGS, NULL},
   49078             :    { (char *)"symbolObj_minx_get", _wrap_symbolObj_minx_get, METH_VARARGS, NULL},
   49079             :    { (char *)"symbolObj_miny_set", _wrap_symbolObj_miny_set, METH_VARARGS, NULL},
   49080             :    { (char *)"symbolObj_miny_get", _wrap_symbolObj_miny_get, METH_VARARGS, NULL},
   49081             :    { (char *)"symbolObj_maxx_set", _wrap_symbolObj_maxx_set, METH_VARARGS, NULL},
   49082             :    { (char *)"symbolObj_maxx_get", _wrap_symbolObj_maxx_get, METH_VARARGS, NULL},
   49083             :    { (char *)"symbolObj_maxy_set", _wrap_symbolObj_maxy_set, METH_VARARGS, NULL},
   49084             :    { (char *)"symbolObj_maxy_get", _wrap_symbolObj_maxy_get, METH_VARARGS, NULL},
   49085             :    { (char *)"symbolObj_refcount_get", _wrap_symbolObj_refcount_get, METH_VARARGS, NULL},
   49086             :    { (char *)"symbolObj_numpoints_get", _wrap_symbolObj_numpoints_get, METH_VARARGS, NULL},
   49087             :    { (char *)"symbolObj_filled_set", _wrap_symbolObj_filled_set, METH_VARARGS, NULL},
   49088             :    { (char *)"symbolObj_filled_get", _wrap_symbolObj_filled_get, METH_VARARGS, NULL},
   49089             :    { (char *)"symbolObj_anchorpoint_x_set", _wrap_symbolObj_anchorpoint_x_set, METH_VARARGS, NULL},
   49090             :    { (char *)"symbolObj_anchorpoint_x_get", _wrap_symbolObj_anchorpoint_x_get, METH_VARARGS, NULL},
   49091             :    { (char *)"symbolObj_anchorpoint_y_set", _wrap_symbolObj_anchorpoint_y_set, METH_VARARGS, NULL},
   49092             :    { (char *)"symbolObj_anchorpoint_y_get", _wrap_symbolObj_anchorpoint_y_get, METH_VARARGS, NULL},
   49093             :    { (char *)"symbolObj_imagepath_get", _wrap_symbolObj_imagepath_get, METH_VARARGS, NULL},
   49094             :    { (char *)"symbolObj_transparent_set", _wrap_symbolObj_transparent_set, METH_VARARGS, NULL},
   49095             :    { (char *)"symbolObj_transparent_get", _wrap_symbolObj_transparent_get, METH_VARARGS, NULL},
   49096             :    { (char *)"symbolObj_transparentcolor_set", _wrap_symbolObj_transparentcolor_set, METH_VARARGS, NULL},
   49097             :    { (char *)"symbolObj_transparentcolor_get", _wrap_symbolObj_transparentcolor_get, METH_VARARGS, NULL},
   49098             :    { (char *)"symbolObj_character_set", _wrap_symbolObj_character_set, METH_VARARGS, NULL},
   49099             :    { (char *)"symbolObj_character_get", _wrap_symbolObj_character_get, METH_VARARGS, NULL},
   49100             :    { (char *)"symbolObj_font_set", _wrap_symbolObj_font_set, METH_VARARGS, NULL},
   49101             :    { (char *)"symbolObj_font_get", _wrap_symbolObj_font_get, METH_VARARGS, NULL},
   49102             :    { (char *)"new_symbolObj", _wrap_new_symbolObj, METH_VARARGS, NULL},
   49103             :    { (char *)"delete_symbolObj", _wrap_delete_symbolObj, METH_VARARGS, NULL},
   49104             :    { (char *)"symbolObj_setImagepath", _wrap_symbolObj_setImagepath, METH_VARARGS, NULL},
   49105             :    { (char *)"symbolObj_setPoints", _wrap_symbolObj_setPoints, METH_VARARGS, NULL},
   49106             :    { (char *)"symbolObj_getPoints", _wrap_symbolObj_getPoints, METH_VARARGS, NULL},
   49107             :    { (char *)"symbolObj_getImage", _wrap_symbolObj_getImage, METH_VARARGS, NULL},
   49108             :    { (char *)"symbolObj_setImage", _wrap_symbolObj_setImage, METH_VARARGS, NULL},
   49109             :    { (char *)"symbolObj_swigregister", symbolObj_swigregister, METH_VARARGS, NULL},
   49110             :    { (char *)"hashTableObj_numitems_get", _wrap_hashTableObj_numitems_get, METH_VARARGS, NULL},
   49111             :    { (char *)"new_hashTableObj", _wrap_new_hashTableObj, METH_VARARGS, NULL},
   49112             :    { (char *)"delete_hashTableObj", _wrap_delete_hashTableObj, METH_VARARGS, NULL},
   49113             :    { (char *)"hashTableObj_set", _wrap_hashTableObj_set, METH_VARARGS, NULL},
   49114             :    { (char *)"hashTableObj_get", _wrap_hashTableObj_get, METH_VARARGS, NULL},
   49115             :    { (char *)"hashTableObj_remove", _wrap_hashTableObj_remove, METH_VARARGS, NULL},
   49116             :    { (char *)"hashTableObj_clear", _wrap_hashTableObj_clear, METH_VARARGS, NULL},
   49117             :    { (char *)"hashTableObj_nextKey", _wrap_hashTableObj_nextKey, METH_VARARGS, NULL},
   49118             :    { (char *)"hashTableObj_swigregister", hashTableObj_swigregister, METH_VARARGS, NULL},
   49119             :    { (char *)"OWSRequest_NumParams_get", _wrap_OWSRequest_NumParams_get, METH_VARARGS, NULL},
   49120             :    { (char *)"OWSRequest_type_set", _wrap_OWSRequest_type_set, METH_VARARGS, NULL},
   49121             :    { (char *)"OWSRequest_type_get", _wrap_OWSRequest_type_get, METH_VARARGS, NULL},
   49122             :    { (char *)"OWSRequest_contenttype_set", _wrap_OWSRequest_contenttype_set, METH_VARARGS, NULL},
   49123             :    { (char *)"OWSRequest_contenttype_get", _wrap_OWSRequest_contenttype_get, METH_VARARGS, NULL},
   49124             :    { (char *)"OWSRequest_postrequest_set", _wrap_OWSRequest_postrequest_set, METH_VARARGS, NULL},
   49125             :    { (char *)"OWSRequest_postrequest_get", _wrap_OWSRequest_postrequest_get, METH_VARARGS, NULL},
   49126             :    { (char *)"OWSRequest_httpcookiedata_set", _wrap_OWSRequest_httpcookiedata_set, METH_VARARGS, NULL},
   49127             :    { (char *)"OWSRequest_httpcookiedata_get", _wrap_OWSRequest_httpcookiedata_get, METH_VARARGS, NULL},
   49128             :    { (char *)"new_OWSRequest", _wrap_new_OWSRequest, METH_VARARGS, NULL},
   49129             :    { (char *)"delete_OWSRequest", _wrap_delete_OWSRequest, METH_VARARGS, NULL},
   49130             :    { (char *)"OWSRequest_loadParams", _wrap_OWSRequest_loadParams, METH_VARARGS, NULL},
   49131             :    { (char *)"OWSRequest_loadParamsFromURL", _wrap_OWSRequest_loadParamsFromURL, METH_VARARGS, NULL},
   49132             :    { (char *)"OWSRequest_setParameter", _wrap_OWSRequest_setParameter, METH_VARARGS, NULL},
   49133             :    { (char *)"OWSRequest_addParameter", _wrap_OWSRequest_addParameter, METH_VARARGS, NULL},
   49134             :    { (char *)"OWSRequest_getName", _wrap_OWSRequest_getName, METH_VARARGS, NULL},
   49135             :    { (char *)"OWSRequest_getValue", _wrap_OWSRequest_getValue, METH_VARARGS, NULL},
   49136             :    { (char *)"OWSRequest_getValueByName", _wrap_OWSRequest_getValueByName, METH_VARARGS, NULL},
   49137             :    { (char *)"OWSRequest_swigregister", OWSRequest_swigregister, METH_VARARGS, NULL},
   49138             :    { (char *)"msConnPoolCloseUnreferenced", _wrap_msConnPoolCloseUnreferenced, METH_VARARGS, NULL},
   49139             :    { (char *)"msIO_resetHandlers", _wrap_msIO_resetHandlers, METH_VARARGS, NULL},
   49140             :    { (char *)"msIO_installStdoutToBuffer", _wrap_msIO_installStdoutToBuffer, METH_VARARGS, NULL},
   49141             :    { (char *)"msIO_installStdinFromBuffer", _wrap_msIO_installStdinFromBuffer, METH_VARARGS, NULL},
   49142             :    { (char *)"msIO_stripStdoutBufferContentType", _wrap_msIO_stripStdoutBufferContentType, METH_VARARGS, NULL},
   49143             :    { (char *)"msIO_stripStdoutBufferContentHeaders", _wrap_msIO_stripStdoutBufferContentHeaders, METH_VARARGS, NULL},
   49144             :    { (char *)"msIO_getStdoutBufferString", _wrap_msIO_getStdoutBufferString, METH_VARARGS, NULL},
   49145             :    { (char *)"msIO_getStdoutBufferBytes", _wrap_msIO_getStdoutBufferBytes, METH_VARARGS, NULL},
   49146             :    { (char *)"msIO_getAndStripStdoutBufferMimeHeaders", _wrap_msIO_getAndStripStdoutBufferMimeHeaders, METH_VARARGS, NULL},
   49147             :    { NULL, NULL, 0, NULL }
   49148             : };
   49149             : 
   49150             : 
   49151             : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
   49152             : 
   49153           0 : static void *_p_intarrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   49154           0 :     return (void *)((int *)  ((intarray *) x));
   49155             : }
   49156             : static swig_type_info _swigt__p_CompositingOperation = {"_p_CompositingOperation", "enum CompositingOperation *|CompositingOperation *", 0, 0, (void*)0, 0};
   49157             : static swig_type_info _swigt__p_DBFFieldType = {"_p_DBFFieldType", "enum DBFFieldType *|DBFFieldType *", 0, 0, (void*)0, 0};
   49158             : static swig_type_info _swigt__p_DBFInfo = {"_p_DBFInfo", "DBFInfo *", 0, 0, (void*)0, 0};
   49159             : static swig_type_info _swigt__p__CompositingFilter = {"_p__CompositingFilter", "struct _CompositingFilter *|_CompositingFilter *|CompositingFilter *", 0, 0, (void*)0, 0};
   49160             : static swig_type_info _swigt__p__LayerCompositer = {"_p__LayerCompositer", "struct _LayerCompositer *|_LayerCompositer *|LayerCompositer *", 0, 0, (void*)0, 0};
   49161             : static swig_type_info _swigt__p_cgiRequestObj = {"_p_cgiRequestObj", "cgiRequestObj *", 0, 0, (void*)0, 0};
   49162             : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
   49163             : static swig_type_info _swigt__p_classObj = {"_p_classObj", "classObj *|struct classObj *", 0, 0, (void*)0, 0};
   49164             : static swig_type_info _swigt__p_clusterObj = {"_p_clusterObj", "clusterObj *", 0, 0, (void*)0, 0};
   49165             : static swig_type_info _swigt__p_colorObj = {"_p_colorObj", "colorObj *", 0, 0, (void*)0, 0};
   49166             : static swig_type_info _swigt__p_debugLevel = {"_p_debugLevel", "enum debugLevel *|debugLevel *", 0, 0, (void*)0, 0};
   49167             : static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
   49168             : static swig_type_info _swigt__p_errorObj = {"_p_errorObj", "struct errorObj *|errorObj *", 0, 0, (void*)0, 0};
   49169             : static swig_type_info _swigt__p_expressionObj = {"_p_expressionObj", "expressionObj *", 0, 0, (void*)0, 0};
   49170             : static swig_type_info _swigt__p_fontSetObj = {"_p_fontSetObj", "fontSetObj *", 0, 0, (void*)0, 0};
   49171             : static swig_type_info _swigt__p_hashTableObj = {"_p_hashTableObj", "hashTableObj *", 0, 0, (void*)0, 0};
   49172             : static swig_type_info _swigt__p_imageObj = {"_p_imageObj", "imageObj *|struct imageObj *", 0, 0, (void*)0, 0};
   49173             : static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
   49174             : static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t *|ms_int32 *", 0, 0, (void*)0, 0};
   49175             : static swig_type_info _swigt__p_intarray = {"_p_intarray", "intarray *", 0, 0, (void*)0, 0};
   49176             : static swig_type_info _swigt__p_labelCacheMemberObj = {"_p_labelCacheMemberObj", "labelCacheMemberObj *", 0, 0, (void*)0, 0};
   49177             : static swig_type_info _swigt__p_labelCacheObj = {"_p_labelCacheObj", "labelCacheObj *", 0, 0, (void*)0, 0};
   49178             : static swig_type_info _swigt__p_labelCacheSlotObj = {"_p_labelCacheSlotObj", "labelCacheSlotObj *", 0, 0, (void*)0, 0};
   49179             : static swig_type_info _swigt__p_labelLeaderObj = {"_p_labelLeaderObj", "labelLeaderObj *", 0, 0, (void*)0, 0};
   49180             : static swig_type_info _swigt__p_labelObj = {"_p_labelObj", "struct labelObj *|labelObj *", 0, 0, (void*)0, 0};
   49181             : static swig_type_info _swigt__p_layerObj = {"_p_layerObj", "struct layerObj *|layerObj *", 0, 0, (void*)0, 0};
   49182             : static swig_type_info _swigt__p_legendObj = {"_p_legendObj", "legendObj *", 0, 0, (void*)0, 0};
   49183             : static swig_type_info _swigt__p_lineObj = {"_p_lineObj", "lineObj *|multipointObj *", 0, 0, (void*)0, 0};
   49184             : static swig_type_info _swigt__p_mapObj = {"_p_mapObj", "struct mapObj *|mapObj *", 0, 0, (void*)0, 0};
   49185             : static swig_type_info _swigt__p_markerCacheMemberObj = {"_p_markerCacheMemberObj", "markerCacheMemberObj *", 0, 0, (void*)0, 0};
   49186             : static swig_type_info _swigt__p_outputFormatObj = {"_p_outputFormatObj", "outputFormatObj *", 0, 0, (void*)0, 0};
   49187             : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
   49188             : static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
   49189             : static swig_type_info _swigt__p_p_labelCacheMemberObj = {"_p_p_labelCacheMemberObj", "labelCacheMemberObj **", 0, 0, (void*)0, 0};
   49190             : static swig_type_info _swigt__p_p_textSymbolObj = {"_p_p_textSymbolObj", "textSymbolObj **", 0, 0, (void*)0, 0};
   49191             : static swig_type_info _swigt__p_pointObj = {"_p_pointObj", "pointObj *", 0, 0, (void*)0, 0};
   49192             : static swig_type_info _swigt__p_projectionContext = {"_p_projectionContext", "struct projectionContext *|projectionContext *", 0, 0, (void*)0, 0};
   49193             : static swig_type_info _swigt__p_projectionObj = {"_p_projectionObj", "projectionObj *", 0, 0, (void*)0, 0};
   49194             : static swig_type_info _swigt__p_queryMapObj = {"_p_queryMapObj", "queryMapObj *", 0, 0, (void*)0, 0};
   49195             : static swig_type_info _swigt__p_rectObj = {"_p_rectObj", "rectObj *", 0, 0, (void*)0, 0};
   49196             : static swig_type_info _swigt__p_referenceMapObj = {"_p_referenceMapObj", "referenceMapObj *", 0, 0, (void*)0, 0};
   49197             : static swig_type_info _swigt__p_resultCacheObj = {"_p_resultCacheObj", "resultCacheObj *", 0, 0, (void*)0, 0};
   49198             : static swig_type_info _swigt__p_resultObj = {"_p_resultObj", "resultObj *", 0, 0, (void*)0, 0};
   49199             : static swig_type_info _swigt__p_scaleTokenEntryObj = {"_p_scaleTokenEntryObj", "scaleTokenEntryObj *", 0, 0, (void*)0, 0};
   49200             : static swig_type_info _swigt__p_scaleTokenObj = {"_p_scaleTokenObj", "scaleTokenObj *", 0, 0, (void*)0, 0};
   49201             : static swig_type_info _swigt__p_scalebarObj = {"_p_scalebarObj", "scalebarObj *", 0, 0, (void*)0, 0};
   49202             : static swig_type_info _swigt__p_shapeObj = {"_p_shapeObj", "shapeObj *", 0, 0, (void*)0, 0};
   49203             : static swig_type_info _swigt__p_shapefileObj = {"_p_shapefileObj", "shapefileObj *", 0, 0, (void*)0, 0};
   49204             : static swig_type_info _swigt__p_styleObj = {"_p_styleObj", "struct styleObj *|styleObj *", 0, 0, (void*)0, 0};
   49205             : static swig_type_info _swigt__p_symbolObj = {"_p_symbolObj", "symbolObj *|struct symbolObj *", 0, 0, (void*)0, 0};
   49206             : static swig_type_info _swigt__p_symbolSetObj = {"_p_symbolSetObj", "symbolSetObj *", 0, 0, (void*)0, 0};
   49207             : static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *|ms_uint32 *", 0, 0, (void*)0, 0};
   49208             : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
   49209             : static swig_type_info _swigt__p_webObj = {"_p_webObj", "webObj *", 0, 0, (void*)0, 0};
   49210             : 
   49211             : static swig_type_info *swig_type_initial[] = {
   49212             :   &_swigt__p_CompositingOperation,
   49213             :   &_swigt__p_DBFFieldType,
   49214             :   &_swigt__p_DBFInfo,
   49215             :   &_swigt__p__CompositingFilter,
   49216             :   &_swigt__p__LayerCompositer,
   49217             :   &_swigt__p_cgiRequestObj,
   49218             :   &_swigt__p_char,
   49219             :   &_swigt__p_classObj,
   49220             :   &_swigt__p_clusterObj,
   49221             :   &_swigt__p_colorObj,
   49222             :   &_swigt__p_debugLevel,
   49223             :   &_swigt__p_double,
   49224             :   &_swigt__p_errorObj,
   49225             :   &_swigt__p_expressionObj,
   49226             :   &_swigt__p_fontSetObj,
   49227             :   &_swigt__p_hashTableObj,
   49228             :   &_swigt__p_imageObj,
   49229             :   &_swigt__p_int,
   49230             :   &_swigt__p_int32_t,
   49231             :   &_swigt__p_intarray,
   49232             :   &_swigt__p_labelCacheMemberObj,
   49233             :   &_swigt__p_labelCacheObj,
   49234             :   &_swigt__p_labelCacheSlotObj,
   49235             :   &_swigt__p_labelLeaderObj,
   49236             :   &_swigt__p_labelObj,
   49237             :   &_swigt__p_layerObj,
   49238             :   &_swigt__p_legendObj,
   49239             :   &_swigt__p_lineObj,
   49240             :   &_swigt__p_mapObj,
   49241             :   &_swigt__p_markerCacheMemberObj,
   49242             :   &_swigt__p_outputFormatObj,
   49243             :   &_swigt__p_p_char,
   49244             :   &_swigt__p_p_double,
   49245             :   &_swigt__p_p_labelCacheMemberObj,
   49246             :   &_swigt__p_p_textSymbolObj,
   49247             :   &_swigt__p_pointObj,
   49248             :   &_swigt__p_projectionContext,
   49249             :   &_swigt__p_projectionObj,
   49250             :   &_swigt__p_queryMapObj,
   49251             :   &_swigt__p_rectObj,
   49252             :   &_swigt__p_referenceMapObj,
   49253             :   &_swigt__p_resultCacheObj,
   49254             :   &_swigt__p_resultObj,
   49255             :   &_swigt__p_scaleTokenEntryObj,
   49256             :   &_swigt__p_scaleTokenObj,
   49257             :   &_swigt__p_scalebarObj,
   49258             :   &_swigt__p_shapeObj,
   49259             :   &_swigt__p_shapefileObj,
   49260             :   &_swigt__p_styleObj,
   49261             :   &_swigt__p_symbolObj,
   49262             :   &_swigt__p_symbolSetObj,
   49263             :   &_swigt__p_uint32_t,
   49264             :   &_swigt__p_void,
   49265             :   &_swigt__p_webObj,
   49266             : };
   49267             : 
   49268             : static swig_cast_info _swigc__p_CompositingOperation[] = {  {&_swigt__p_CompositingOperation, 0, 0, 0},{0, 0, 0, 0}};
   49269             : static swig_cast_info _swigc__p_DBFFieldType[] = {  {&_swigt__p_DBFFieldType, 0, 0, 0},{0, 0, 0, 0}};
   49270             : static swig_cast_info _swigc__p_DBFInfo[] = {  {&_swigt__p_DBFInfo, 0, 0, 0},{0, 0, 0, 0}};
   49271             : static swig_cast_info _swigc__p__CompositingFilter[] = {  {&_swigt__p__CompositingFilter, 0, 0, 0},{0, 0, 0, 0}};
   49272             : static swig_cast_info _swigc__p__LayerCompositer[] = {  {&_swigt__p__LayerCompositer, 0, 0, 0},{0, 0, 0, 0}};
   49273             : static swig_cast_info _swigc__p_cgiRequestObj[] = {  {&_swigt__p_cgiRequestObj, 0, 0, 0},{0, 0, 0, 0}};
   49274             : static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
   49275             : static swig_cast_info _swigc__p_classObj[] = {  {&_swigt__p_classObj, 0, 0, 0},{0, 0, 0, 0}};
   49276             : static swig_cast_info _swigc__p_clusterObj[] = {  {&_swigt__p_clusterObj, 0, 0, 0},{0, 0, 0, 0}};
   49277             : static swig_cast_info _swigc__p_colorObj[] = {  {&_swigt__p_colorObj, 0, 0, 0},{0, 0, 0, 0}};
   49278             : static swig_cast_info _swigc__p_debugLevel[] = {  {&_swigt__p_debugLevel, 0, 0, 0},{0, 0, 0, 0}};
   49279             : static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
   49280             : static swig_cast_info _swigc__p_errorObj[] = {  {&_swigt__p_errorObj, 0, 0, 0},{0, 0, 0, 0}};
   49281             : static swig_cast_info _swigc__p_expressionObj[] = {  {&_swigt__p_expressionObj, 0, 0, 0},{0, 0, 0, 0}};
   49282             : static swig_cast_info _swigc__p_fontSetObj[] = {  {&_swigt__p_fontSetObj, 0, 0, 0},{0, 0, 0, 0}};
   49283             : static swig_cast_info _swigc__p_hashTableObj[] = {  {&_swigt__p_hashTableObj, 0, 0, 0},{0, 0, 0, 0}};
   49284             : static swig_cast_info _swigc__p_imageObj[] = {  {&_swigt__p_imageObj, 0, 0, 0},{0, 0, 0, 0}};
   49285             : static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},  {&_swigt__p_intarray, _p_intarrayTo_p_int, 0, 0},{0, 0, 0, 0}};
   49286             : static swig_cast_info _swigc__p_int32_t[] = {  {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
   49287             : static swig_cast_info _swigc__p_intarray[] = {  {&_swigt__p_intarray, 0, 0, 0},{0, 0, 0, 0}};
   49288             : static swig_cast_info _swigc__p_labelCacheMemberObj[] = {  {&_swigt__p_labelCacheMemberObj, 0, 0, 0},{0, 0, 0, 0}};
   49289             : static swig_cast_info _swigc__p_labelCacheObj[] = {  {&_swigt__p_labelCacheObj, 0, 0, 0},{0, 0, 0, 0}};
   49290             : static swig_cast_info _swigc__p_labelCacheSlotObj[] = {  {&_swigt__p_labelCacheSlotObj, 0, 0, 0},{0, 0, 0, 0}};
   49291             : static swig_cast_info _swigc__p_labelLeaderObj[] = {  {&_swigt__p_labelLeaderObj, 0, 0, 0},{0, 0, 0, 0}};
   49292             : static swig_cast_info _swigc__p_labelObj[] = {  {&_swigt__p_labelObj, 0, 0, 0},{0, 0, 0, 0}};
   49293             : static swig_cast_info _swigc__p_layerObj[] = {  {&_swigt__p_layerObj, 0, 0, 0},{0, 0, 0, 0}};
   49294             : static swig_cast_info _swigc__p_legendObj[] = {  {&_swigt__p_legendObj, 0, 0, 0},{0, 0, 0, 0}};
   49295             : static swig_cast_info _swigc__p_lineObj[] = {  {&_swigt__p_lineObj, 0, 0, 0},{0, 0, 0, 0}};
   49296             : static swig_cast_info _swigc__p_mapObj[] = {  {&_swigt__p_mapObj, 0, 0, 0},{0, 0, 0, 0}};
   49297             : static swig_cast_info _swigc__p_markerCacheMemberObj[] = {  {&_swigt__p_markerCacheMemberObj, 0, 0, 0},{0, 0, 0, 0}};
   49298             : static swig_cast_info _swigc__p_outputFormatObj[] = {  {&_swigt__p_outputFormatObj, 0, 0, 0},{0, 0, 0, 0}};
   49299             : static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
   49300             : static swig_cast_info _swigc__p_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
   49301             : static swig_cast_info _swigc__p_p_labelCacheMemberObj[] = {  {&_swigt__p_p_labelCacheMemberObj, 0, 0, 0},{0, 0, 0, 0}};
   49302             : static swig_cast_info _swigc__p_p_textSymbolObj[] = {  {&_swigt__p_p_textSymbolObj, 0, 0, 0},{0, 0, 0, 0}};
   49303             : static swig_cast_info _swigc__p_pointObj[] = {  {&_swigt__p_pointObj, 0, 0, 0},{0, 0, 0, 0}};
   49304             : static swig_cast_info _swigc__p_projectionContext[] = {  {&_swigt__p_projectionContext, 0, 0, 0},{0, 0, 0, 0}};
   49305             : static swig_cast_info _swigc__p_projectionObj[] = {  {&_swigt__p_projectionObj, 0, 0, 0},{0, 0, 0, 0}};
   49306             : static swig_cast_info _swigc__p_queryMapObj[] = {  {&_swigt__p_queryMapObj, 0, 0, 0},{0, 0, 0, 0}};
   49307             : static swig_cast_info _swigc__p_rectObj[] = {  {&_swigt__p_rectObj, 0, 0, 0},{0, 0, 0, 0}};
   49308             : static swig_cast_info _swigc__p_referenceMapObj[] = {  {&_swigt__p_referenceMapObj, 0, 0, 0},{0, 0, 0, 0}};
   49309             : static swig_cast_info _swigc__p_resultCacheObj[] = {  {&_swigt__p_resultCacheObj, 0, 0, 0},{0, 0, 0, 0}};
   49310             : static swig_cast_info _swigc__p_resultObj[] = {  {&_swigt__p_resultObj, 0, 0, 0},{0, 0, 0, 0}};
   49311             : static swig_cast_info _swigc__p_scaleTokenEntryObj[] = {  {&_swigt__p_scaleTokenEntryObj, 0, 0, 0},{0, 0, 0, 0}};
   49312             : static swig_cast_info _swigc__p_scaleTokenObj[] = {  {&_swigt__p_scaleTokenObj, 0, 0, 0},{0, 0, 0, 0}};
   49313             : static swig_cast_info _swigc__p_scalebarObj[] = {  {&_swigt__p_scalebarObj, 0, 0, 0},{0, 0, 0, 0}};
   49314             : static swig_cast_info _swigc__p_shapeObj[] = {  {&_swigt__p_shapeObj, 0, 0, 0},{0, 0, 0, 0}};
   49315             : static swig_cast_info _swigc__p_shapefileObj[] = {  {&_swigt__p_shapefileObj, 0, 0, 0},{0, 0, 0, 0}};
   49316             : static swig_cast_info _swigc__p_styleObj[] = {  {&_swigt__p_styleObj, 0, 0, 0},{0, 0, 0, 0}};
   49317             : static swig_cast_info _swigc__p_symbolObj[] = {  {&_swigt__p_symbolObj, 0, 0, 0},{0, 0, 0, 0}};
   49318             : static swig_cast_info _swigc__p_symbolSetObj[] = {  {&_swigt__p_symbolSetObj, 0, 0, 0},{0, 0, 0, 0}};
   49319             : static swig_cast_info _swigc__p_uint32_t[] = {  {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
   49320             : static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
   49321             : static swig_cast_info _swigc__p_webObj[] = {  {&_swigt__p_webObj, 0, 0, 0},{0, 0, 0, 0}};
   49322             : 
   49323             : static swig_cast_info *swig_cast_initial[] = {
   49324             :   _swigc__p_CompositingOperation,
   49325             :   _swigc__p_DBFFieldType,
   49326             :   _swigc__p_DBFInfo,
   49327             :   _swigc__p__CompositingFilter,
   49328             :   _swigc__p__LayerCompositer,
   49329             :   _swigc__p_cgiRequestObj,
   49330             :   _swigc__p_char,
   49331             :   _swigc__p_classObj,
   49332             :   _swigc__p_clusterObj,
   49333             :   _swigc__p_colorObj,
   49334             :   _swigc__p_debugLevel,
   49335             :   _swigc__p_double,
   49336             :   _swigc__p_errorObj,
   49337             :   _swigc__p_expressionObj,
   49338             :   _swigc__p_fontSetObj,
   49339             :   _swigc__p_hashTableObj,
   49340             :   _swigc__p_imageObj,
   49341             :   _swigc__p_int,
   49342             :   _swigc__p_int32_t,
   49343             :   _swigc__p_intarray,
   49344             :   _swigc__p_labelCacheMemberObj,
   49345             :   _swigc__p_labelCacheObj,
   49346             :   _swigc__p_labelCacheSlotObj,
   49347             :   _swigc__p_labelLeaderObj,
   49348             :   _swigc__p_labelObj,
   49349             :   _swigc__p_layerObj,
   49350             :   _swigc__p_legendObj,
   49351             :   _swigc__p_lineObj,
   49352             :   _swigc__p_mapObj,
   49353             :   _swigc__p_markerCacheMemberObj,
   49354             :   _swigc__p_outputFormatObj,
   49355             :   _swigc__p_p_char,
   49356             :   _swigc__p_p_double,
   49357             :   _swigc__p_p_labelCacheMemberObj,
   49358             :   _swigc__p_p_textSymbolObj,
   49359             :   _swigc__p_pointObj,
   49360             :   _swigc__p_projectionContext,
   49361             :   _swigc__p_projectionObj,
   49362             :   _swigc__p_queryMapObj,
   49363             :   _swigc__p_rectObj,
   49364             :   _swigc__p_referenceMapObj,
   49365             :   _swigc__p_resultCacheObj,
   49366             :   _swigc__p_resultObj,
   49367             :   _swigc__p_scaleTokenEntryObj,
   49368             :   _swigc__p_scaleTokenObj,
   49369             :   _swigc__p_scalebarObj,
   49370             :   _swigc__p_shapeObj,
   49371             :   _swigc__p_shapefileObj,
   49372             :   _swigc__p_styleObj,
   49373             :   _swigc__p_symbolObj,
   49374             :   _swigc__p_symbolSetObj,
   49375             :   _swigc__p_uint32_t,
   49376             :   _swigc__p_void,
   49377             :   _swigc__p_webObj,
   49378             : };
   49379             : 
   49380             : 
   49381             : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
   49382             : 
   49383             : static swig_const_info swig_const_table[] = {
   49384             : {0, 0, 0, 0.0, 0, 0}};
   49385             : 
   49386             : #ifdef __cplusplus
   49387             : }
   49388             : #endif
   49389             : /* -----------------------------------------------------------------------------
   49390             :  * Type initialization:
   49391             :  * This problem is tough by the requirement that no dynamic
   49392             :  * memory is used. Also, since swig_type_info structures store pointers to
   49393             :  * swig_cast_info structures and swig_cast_info structures store pointers back
   49394             :  * to swig_type_info structures, we need some lookup code at initialization.
   49395             :  * The idea is that swig generates all the structures that are needed.
   49396             :  * The runtime then collects these partially filled structures.
   49397             :  * The SWIG_InitializeModule function takes these initial arrays out of
   49398             :  * swig_module, and does all the lookup, filling in the swig_module.types
   49399             :  * array with the correct data and linking the correct swig_cast_info
   49400             :  * structures together.
   49401             :  *
   49402             :  * The generated swig_type_info structures are assigned statically to an initial
   49403             :  * array. We just loop through that array, and handle each type individually.
   49404             :  * First we lookup if this type has been already loaded, and if so, use the
   49405             :  * loaded structure instead of the generated one. Then we have to fill in the
   49406             :  * cast linked list. The cast data is initially stored in something like a
   49407             :  * two-dimensional array. Each row corresponds to a type (there are the same
   49408             :  * number of rows as there are in the swig_type_initial array). Each entry in
   49409             :  * a column is one of the swig_cast_info structures for that type.
   49410             :  * The cast_initial array is actually an array of arrays, because each row has
   49411             :  * a variable number of columns. So to actually build the cast linked list,
   49412             :  * we find the array of casts associated with the type, and loop through it
   49413             :  * adding the casts to the list. The one last trick we need to do is making
   49414             :  * sure the type pointer in the swig_cast_info struct is correct.
   49415             :  *
   49416             :  * First off, we lookup the cast->type name to see if it is already loaded.
   49417             :  * There are three cases to handle:
   49418             :  *  1) If the cast->type has already been loaded AND the type we are adding
   49419             :  *     casting info to has not been loaded (it is in this module), THEN we
   49420             :  *     replace the cast->type pointer with the type pointer that has already
   49421             :  *     been loaded.
   49422             :  *  2) If BOTH types (the one we are adding casting info to, and the
   49423             :  *     cast->type) are loaded, THEN the cast info has already been loaded by
   49424             :  *     the previous module so we just ignore it.
   49425             :  *  3) Finally, if cast->type has not already been loaded, then we add that
   49426             :  *     swig_cast_info to the linked list (because the cast->type) pointer will
   49427             :  *     be correct.
   49428             :  * ----------------------------------------------------------------------------- */
   49429             : 
   49430             : #ifdef __cplusplus
   49431             : extern "C" {
   49432             : #if 0
   49433             : } /* c-mode */
   49434             : #endif
   49435             : #endif
   49436             : 
   49437             : #if 0
   49438             : #define SWIGRUNTIME_DEBUG
   49439             : #endif
   49440             : 
   49441             : 
   49442             : SWIGRUNTIME void
   49443           1 : SWIG_InitializeModule(void *clientdata) {
   49444             :   size_t i;
   49445             :   swig_module_info *module_head, *iter;
   49446             :   int init;
   49447             :   
   49448             :   /* check to see if the circular list has been setup, if not, set it up */
   49449           1 :   if (swig_module.next==0) {
   49450             :     /* Initialize the swig_module */
   49451           1 :     swig_module.type_initial = swig_type_initial;
   49452           1 :     swig_module.cast_initial = swig_cast_initial;
   49453           1 :     swig_module.next = &swig_module;
   49454             :     init = 1;
   49455             :   } else {
   49456             :     init = 0;
   49457             :   }
   49458             :   
   49459             :   /* Try and load any already created modules */
   49460           1 :   module_head = SWIG_GetModule(clientdata);
   49461           1 :   if (!module_head) {
   49462             :     /* This is the first module loaded for this interpreter */
   49463             :     /* so set the swig module into the interpreter */
   49464           1 :     SWIG_SetModule(clientdata, &swig_module);
   49465             :   } else {
   49466             :     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
   49467             :     iter=module_head;
   49468             :     do {
   49469           0 :       if (iter==&swig_module) {
   49470             :         /* Our module is already in the list, so there's nothing more to do. */
   49471             :         return;
   49472             :       }
   49473           0 :       iter=iter->next;
   49474           0 :     } while (iter!= module_head);
   49475             :     
   49476             :     /* otherwise we must add our module into the list */
   49477           0 :     swig_module.next = module_head->next;
   49478           0 :     module_head->next = &swig_module;
   49479             :   }
   49480             :   
   49481             :   /* When multiple interpreters are used, a module could have already been initialized in
   49482             :        a different interpreter, but not yet have a pointer in this interpreter.
   49483             :        In this case, we do not want to continue adding types... everything should be
   49484             :        set up already */
   49485           1 :   if (init == 0) return;
   49486             :   
   49487             :   /* Now work on filling in swig_module.types */
   49488             : #ifdef SWIGRUNTIME_DEBUG
   49489             :   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
   49490             : #endif
   49491           1 :   for (i = 0; i < swig_module.size; ++i) {
   49492             :     swig_type_info *type = 0;
   49493             :     swig_type_info *ret;
   49494             :     swig_cast_info *cast;
   49495             :     
   49496             : #ifdef SWIGRUNTIME_DEBUG
   49497             :     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
   49498             : #endif
   49499             :     
   49500             :     /* if there is another module already loaded */
   49501           1 :     if (swig_module.next != &swig_module) {
   49502           0 :       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
   49503             :     }
   49504           0 :     if (type) {
   49505             :       /* Overwrite clientdata field */
   49506             : #ifdef SWIGRUNTIME_DEBUG
   49507             :       printf("SWIG_InitializeModule: found type %s\n", type->name);
   49508             : #endif
   49509           0 :       if (swig_module.type_initial[i]->clientdata) {
   49510           0 :         type->clientdata = swig_module.type_initial[i]->clientdata;
   49511             : #ifdef SWIGRUNTIME_DEBUG
   49512             :         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
   49513             : #endif
   49514             :       }
   49515             :     } else {
   49516           1 :       type = swig_module.type_initial[i];
   49517             :     }
   49518             :     
   49519             :     /* Insert casting types */
   49520           1 :     cast = swig_module.cast_initial[i];
   49521           1 :     while (cast->type) {
   49522             :       /* Don't need to add information already in the list */
   49523             :       ret = 0;
   49524             : #ifdef SWIGRUNTIME_DEBUG
   49525             :       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
   49526             : #endif
   49527           1 :       if (swig_module.next != &swig_module) {
   49528           0 :         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
   49529             : #ifdef SWIGRUNTIME_DEBUG
   49530             :         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
   49531             : #endif
   49532             :       }
   49533           0 :       if (ret) {
   49534           0 :         if (type == swig_module.type_initial[i]) {
   49535             : #ifdef SWIGRUNTIME_DEBUG
   49536             :           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
   49537             : #endif
   49538           0 :           cast->type = ret;
   49539             :           ret = 0;
   49540             :         } else {
   49541             :           /* Check for casting already in the list */
   49542           0 :           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
   49543             : #ifdef SWIGRUNTIME_DEBUG
   49544             :           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
   49545             : #endif
   49546           0 :           if (!ocast) ret = 0;
   49547             :         }
   49548             :       }
   49549             :       
   49550           1 :       if (!ret) {
   49551             : #ifdef SWIGRUNTIME_DEBUG
   49552             :         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
   49553             : #endif
   49554           1 :         if (type->cast) {
   49555           1 :           type->cast->prev = cast;
   49556           1 :           cast->next = type->cast;
   49557             :         }
   49558           1 :         type->cast = cast;
   49559             :       }
   49560           1 :       cast++;
   49561             :     }
   49562             :     /* Set entry in modules->types array equal to the type */
   49563           1 :     swig_module.types[i] = type;
   49564             :   }
   49565           1 :   swig_module.types[i] = 0;
   49566             :   
   49567             : #ifdef SWIGRUNTIME_DEBUG
   49568             :   printf("**** SWIG_InitializeModule: Cast List ******\n");
   49569             :   for (i = 0; i < swig_module.size; ++i) {
   49570             :     int j = 0;
   49571             :     swig_cast_info *cast = swig_module.cast_initial[i];
   49572             :     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
   49573             :     while (cast->type) {
   49574             :       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
   49575             :       cast++;
   49576             :       ++j;
   49577             :     }
   49578             :     printf("---- Total casts: %d\n",j);
   49579             :   }
   49580             :   printf("**** SWIG_InitializeModule: Cast List ******\n");
   49581             : #endif
   49582             : }
   49583             : 
   49584             : /* This function will propagate the clientdata field of type to
   49585             : * any new swig_type_info structures that have been added into the list
   49586             : * of equivalent types.  It is like calling
   49587             : * SWIG_TypeClientData(type, clientdata) a second time.
   49588             : */
   49589             : SWIGRUNTIME void
   49590             : SWIG_PropagateClientData(void) {
   49591             :   size_t i;
   49592             :   swig_cast_info *equiv;
   49593             :   static int init_run = 0;
   49594             :   
   49595             :   if (init_run) return;
   49596             :   init_run = 1;
   49597             :   
   49598             :   for (i = 0; i < swig_module.size; i++) {
   49599             :     if (swig_module.types[i]->clientdata) {
   49600             :       equiv = swig_module.types[i]->cast;
   49601             :       while (equiv) {
   49602             :         if (!equiv->converter) {
   49603             :           if (equiv->type && !equiv->type->clientdata)
   49604             :           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
   49605             :         }
   49606             :         equiv = equiv->next;
   49607             :       }
   49608             :     }
   49609             :   }
   49610             : }
   49611             : 
   49612             : #ifdef __cplusplus
   49613             : #if 0
   49614             : {
   49615             :   /* c-mode */
   49616             : #endif
   49617             : }
   49618             : #endif
   49619             : 
   49620             : 
   49621             : 
   49622             : #ifdef __cplusplus
   49623             : extern "C" {
   49624             : #endif
   49625             :   
   49626             :   /* Python-specific SWIG API */
   49627             : #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
   49628             : #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
   49629             : #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
   49630             :   
   49631             :   /* -----------------------------------------------------------------------------
   49632             :    * global variable support code.
   49633             :    * ----------------------------------------------------------------------------- */
   49634             :   
   49635             :   typedef struct swig_globalvar {
   49636             :     char       *name;                  /* Name of global variable */
   49637             :     PyObject *(*get_attr)(void);       /* Return the current value */
   49638             :     int       (*set_attr)(PyObject *); /* Set the value */
   49639             :     struct swig_globalvar *next;
   49640             :   } swig_globalvar;
   49641             :   
   49642             :   typedef struct swig_varlinkobject {
   49643             :     PyObject_HEAD
   49644             :     swig_globalvar *vars;
   49645             :   } swig_varlinkobject;
   49646             :   
   49647             :   SWIGINTERN PyObject *
   49648             :   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
   49649             : #if PY_VERSION_HEX >= 0x03000000
   49650             :     return PyUnicode_InternFromString("<Swig global variables>");
   49651             : #else
   49652             :     return PyString_FromString("<Swig global variables>");
   49653             : #endif
   49654             :   }
   49655             :   
   49656             :   SWIGINTERN PyObject *
   49657             :   swig_varlink_str(swig_varlinkobject *v) {
   49658             : #if PY_VERSION_HEX >= 0x03000000
   49659             :     PyObject *str = PyUnicode_InternFromString("(");
   49660             :     PyObject *tail;
   49661             :     PyObject *joined;
   49662             :     swig_globalvar *var;
   49663             :     for (var = v->vars; var; var=var->next) {
   49664             :       tail = PyUnicode_FromString(var->name);
   49665             :       joined = PyUnicode_Concat(str, tail);
   49666             :       Py_DecRef(str);
   49667             :       Py_DecRef(tail);
   49668             :       str = joined;
   49669             :       if (var->next) {
   49670             :         tail = PyUnicode_InternFromString(", ");
   49671             :         joined = PyUnicode_Concat(str, tail);
   49672             :         Py_DecRef(str);
   49673             :         Py_DecRef(tail);
   49674             :         str = joined;
   49675             :       }
   49676             :     }
   49677             :     tail = PyUnicode_InternFromString(")");
   49678             :     joined = PyUnicode_Concat(str, tail);
   49679             :     Py_DecRef(str);
   49680             :     Py_DecRef(tail);
   49681             :     str = joined;
   49682             : #else
   49683             :     PyObject *str = PyString_FromString("(");
   49684             :     swig_globalvar *var;
   49685             :     for (var = v->vars; var; var=var->next) {
   49686             :       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
   49687             :       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
   49688             :     }
   49689             :     PyString_ConcatAndDel(&str,PyString_FromString(")"));
   49690             : #endif
   49691             :     return str;
   49692             :   }
   49693             :   
   49694             :   SWIGINTERN int
   49695             :   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
   49696             :     char *tmp;
   49697             :     PyObject *str = swig_varlink_str(v);
   49698             :     fprintf(fp,"Swig global variables ");
   49699             :     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
   49700             :     SWIG_Python_str_DelForPy3(tmp);
   49701             :     Py_DECREF(str);
   49702             :     return 0;
   49703             :   }
   49704             :   
   49705             :   SWIGINTERN void
   49706             :   swig_varlink_dealloc(swig_varlinkobject *v) {
   49707             :     swig_globalvar *var = v->vars;
   49708             :     while (var) {
   49709             :       swig_globalvar *n = var->next;
   49710             :       free(var->name);
   49711             :       free(var);
   49712             :       var = n;
   49713             :     }
   49714             :   }
   49715             :   
   49716             :   SWIGINTERN PyObject *
   49717             :   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
   49718             :     PyObject *res = NULL;
   49719             :     swig_globalvar *var = v->vars;
   49720             :     while (var) {
   49721             :       if (strcmp(var->name,n) == 0) {
   49722             :         res = (*var->get_attr)();
   49723             :         break;
   49724             :       }
   49725             :       var = var->next;
   49726             :     }
   49727             :     if (res == NULL && !PyErr_Occurred()) {
   49728             :       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
   49729             :     }
   49730             :     return res;
   49731             :   }
   49732             :   
   49733             :   SWIGINTERN int
   49734             :   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
   49735             :     int res = 1;
   49736             :     swig_globalvar *var = v->vars;
   49737             :     while (var) {
   49738             :       if (strcmp(var->name,n) == 0) {
   49739             :         res = (*var->set_attr)(p);
   49740             :         break;
   49741             :       }
   49742             :       var = var->next;
   49743             :     }
   49744             :     if (res == 1 && !PyErr_Occurred()) {
   49745             :       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
   49746             :     }
   49747             :     return res;
   49748             :   }
   49749             :   
   49750             :   SWIGINTERN PyTypeObject*
   49751             :   swig_varlink_type(void) {
   49752             :     static char varlink__doc__[] = "Swig var link object";
   49753             :     static PyTypeObject varlink_type;
   49754             :     static int type_init = 0;
   49755             :     if (!type_init) {
   49756             :       const PyTypeObject tmp = {
   49757             : #if PY_VERSION_HEX >= 0x03000000
   49758             :         PyVarObject_HEAD_INIT(NULL, 0)
   49759             : #else
   49760             :         PyObject_HEAD_INIT(NULL)
   49761             :         0,                                  /* ob_size */
   49762             : #endif
   49763             :         (char *)"swigvarlink",              /* tp_name */
   49764             :         sizeof(swig_varlinkobject),         /* tp_basicsize */
   49765             :         0,                                  /* tp_itemsize */
   49766             :         (destructor) swig_varlink_dealloc,  /* tp_dealloc */
   49767             :         (printfunc) swig_varlink_print,     /* tp_print */
   49768             :         (getattrfunc) swig_varlink_getattr, /* tp_getattr */
   49769             :         (setattrfunc) swig_varlink_setattr, /* tp_setattr */
   49770             :         0,                                  /* tp_compare */
   49771             :         (reprfunc) swig_varlink_repr,       /* tp_repr */
   49772             :         0,                                  /* tp_as_number */
   49773             :         0,                                  /* tp_as_sequence */
   49774             :         0,                                  /* tp_as_mapping */
   49775             :         0,                                  /* tp_hash */
   49776             :         0,                                  /* tp_call */
   49777             :         (reprfunc) swig_varlink_str,        /* tp_str */
   49778             :         0,                                  /* tp_getattro */
   49779             :         0,                                  /* tp_setattro */
   49780             :         0,                                  /* tp_as_buffer */
   49781             :         0,                                  /* tp_flags */
   49782             :         varlink__doc__,                     /* tp_doc */
   49783             :         0,                                  /* tp_traverse */
   49784             :         0,                                  /* tp_clear */
   49785             :         0,                                  /* tp_richcompare */
   49786             :         0,                                  /* tp_weaklistoffset */
   49787             : #if PY_VERSION_HEX >= 0x02020000
   49788             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
   49789             : #endif
   49790             : #if PY_VERSION_HEX >= 0x02030000
   49791             :         0,                                  /* tp_del */
   49792             : #endif
   49793             : #if PY_VERSION_HEX >= 0x02060000
   49794             :         0,                                  /* tp_version_tag */
   49795             : #endif
   49796             : #if PY_VERSION_HEX >= 0x03040000
   49797             :         0,                                  /* tp_finalize */
   49798             : #endif
   49799             : #ifdef COUNT_ALLOCS
   49800             :         0,                                  /* tp_allocs */
   49801             :         0,                                  /* tp_frees */
   49802             :         0,                                  /* tp_maxalloc */
   49803             : #if PY_VERSION_HEX >= 0x02050000
   49804             :         0,                                  /* tp_prev */
   49805             : #endif
   49806             :         0                                   /* tp_next */
   49807             : #endif
   49808             :       };
   49809             :       varlink_type = tmp;
   49810             :       type_init = 1;
   49811             : #if PY_VERSION_HEX < 0x02020000
   49812             :       varlink_type.ob_type = &PyType_Type;
   49813             : #else
   49814             :       if (PyType_Ready(&varlink_type) < 0)
   49815             :       return NULL;
   49816             : #endif
   49817             :     }
   49818             :     return &varlink_type;
   49819             :   }
   49820             :   
   49821             :   /* Create a variable linking object for use later */
   49822             :   SWIGINTERN PyObject *
   49823             :   SWIG_Python_newvarlink(void) {
   49824             :     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
   49825             :     if (result) {
   49826             :       result->vars = 0;
   49827             :     }
   49828             :     return ((PyObject*) result);
   49829             :   }
   49830             :   
   49831             :   SWIGINTERN void 
   49832             :   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
   49833             :     swig_varlinkobject *v = (swig_varlinkobject *) p;
   49834             :     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
   49835             :     if (gv) {
   49836             :       size_t size = strlen(name)+1;
   49837             :       gv->name = (char *)malloc(size);
   49838             :       if (gv->name) {
   49839             :         strncpy(gv->name,name,size);
   49840             :         gv->get_attr = get_attr;
   49841             :         gv->set_attr = set_attr;
   49842             :         gv->next = v->vars;
   49843             :       }
   49844             :     }
   49845             :     v->vars = gv;
   49846             :   }
   49847             :   
   49848             :   SWIGINTERN PyObject *
   49849             :   SWIG_globals(void) {
   49850             :     static PyObject *_SWIG_globals = 0; 
   49851             :     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
   49852             :     return _SWIG_globals;
   49853             :   }
   49854             :   
   49855             :   /* -----------------------------------------------------------------------------
   49856             :    * constants/methods manipulation
   49857             :    * ----------------------------------------------------------------------------- */
   49858             :   
   49859             :   /* Install Constants */
   49860             :   SWIGINTERN void
   49861           1 :   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
   49862             :     PyObject *obj = 0;
   49863             :     size_t i;
   49864           1 :     for (i = 0; constants[i].type; ++i) {
   49865           0 :       switch(constants[i].type) {
   49866           0 :       case SWIG_PY_POINTER:
   49867           0 :         obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
   49868           0 :         break;
   49869           0 :       case SWIG_PY_BINARY:
   49870           0 :         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
   49871             :         break;
   49872             :       default:
   49873             :         obj = 0;
   49874             :         break;
   49875             :       }
   49876           0 :       if (obj) {
   49877           0 :         PyDict_SetItemString(d, constants[i].name, obj);
   49878           0 :         Py_DECREF(obj);
   49879             :       }
   49880             :     }
   49881           1 :   }
   49882             :   
   49883             :   /* -----------------------------------------------------------------------------*/
   49884             :   /* Fix SwigMethods to carry the callback ptrs when needed */
   49885             :   /* -----------------------------------------------------------------------------*/
   49886             :   
   49887             :   SWIGINTERN void
   49888           1 :   SWIG_Python_FixMethods(PyMethodDef *methods,
   49889             :     swig_const_info *const_table,
   49890             :     swig_type_info **types,
   49891             :     swig_type_info **types_initial) {
   49892             :     size_t i;
   49893           1 :     for (i = 0; methods[i].ml_name; ++i) {
   49894           1 :       const char *c = methods[i].ml_doc;
   49895           1 :       if (!c) continue;
   49896           1 :       c = strstr(c, "swig_ptr: ");
   49897           1 :       if (c) {
   49898             :         int j;
   49899             :         swig_const_info *ci = 0;
   49900           0 :         const char *name = c + 10;
   49901           0 :         for (j = 0; const_table[j].type; ++j) {
   49902           0 :           if (strncmp(const_table[j].name, name, 
   49903           0 :               strlen(const_table[j].name)) == 0) {
   49904             :             ci = &(const_table[j]);
   49905             :             break;
   49906             :           }
   49907             :         }
   49908           0 :         if (ci) {
   49909           0 :           void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
   49910           0 :           if (ptr) {
   49911           0 :             size_t shift = (ci->ptype) - types;
   49912           0 :             swig_type_info *ty = types_initial[shift];
   49913           0 :             size_t ldoc = (c - methods[i].ml_doc);
   49914           0 :             size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
   49915           0 :             char *ndoc = (char*)malloc(ldoc + lptr + 10);
   49916           0 :             if (ndoc) {
   49917             :               char *buff = ndoc;
   49918             :               strncpy(buff, methods[i].ml_doc, ldoc);
   49919           0 :               buff += ldoc;
   49920             :               strncpy(buff, "swig_ptr: ", 10);
   49921           0 :               buff += 10;
   49922           0 :               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
   49923           0 :               methods[i].ml_doc = ndoc;
   49924             :             }
   49925             :           }
   49926             :         }
   49927             :       }
   49928             :     }
   49929           1 :   } 
   49930             :   
   49931             : #ifdef __cplusplus
   49932             : }
   49933             : #endif
   49934             : 
   49935             : /* -----------------------------------------------------------------------------*
   49936             :  *  Partial Init method
   49937             :  * -----------------------------------------------------------------------------*/
   49938             : 
   49939             : #ifdef __cplusplus
   49940             : extern "C"
   49941             : #endif
   49942             : 
   49943             : SWIGEXPORT 
   49944             : #if PY_VERSION_HEX >= 0x03000000
   49945             : PyObject*
   49946             : #else
   49947             : void
   49948             : #endif
   49949           1 : SWIG_init(void) {
   49950             :   PyObject *m, *d, *md;
   49951             : #if PY_VERSION_HEX >= 0x03000000
   49952             :   static struct PyModuleDef SWIG_module = {
   49953             : # if PY_VERSION_HEX >= 0x03020000
   49954             :     PyModuleDef_HEAD_INIT,
   49955             : # else
   49956             :     {
   49957             :       PyObject_HEAD_INIT(NULL)
   49958             :       NULL, /* m_init */
   49959             :       0,    /* m_index */
   49960             :       NULL, /* m_copy */
   49961             :     },
   49962             : # endif
   49963             :     (char *) SWIG_name,
   49964             :     NULL,
   49965             :     -1,
   49966             :     SwigMethods,
   49967             :     NULL,
   49968             :     NULL,
   49969             :     NULL,
   49970             :     NULL
   49971             :   };
   49972             : #endif
   49973             :   
   49974             : #if defined(SWIGPYTHON_BUILTIN)
   49975             :   static SwigPyClientData SwigPyObject_clientdata = {
   49976             :     0, 0, 0, 0, 0, 0, 0
   49977             :   };
   49978             :   static PyGetSetDef this_getset_def = {
   49979             :     (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
   49980             :   };
   49981             :   static SwigPyGetSet thisown_getset_closure = {
   49982             :     (PyCFunction) SwigPyObject_own,
   49983             :     (PyCFunction) SwigPyObject_own
   49984             :   };
   49985             :   static PyGetSetDef thisown_getset_def = {
   49986             :     (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
   49987             :   };
   49988             :   PyTypeObject *builtin_pytype;
   49989             :   int builtin_base_count;
   49990             :   swig_type_info *builtin_basetype;
   49991             :   PyObject *tuple;
   49992             :   PyGetSetDescrObject *static_getset;
   49993             :   PyTypeObject *metatype;
   49994             :   PyTypeObject *swigpyobject;
   49995             :   SwigPyClientData *cd;
   49996             :   PyObject *public_interface, *public_symbol;
   49997             :   PyObject *this_descr;
   49998             :   PyObject *thisown_descr;
   49999             :   PyObject *self = 0;
   50000             :   int i;
   50001             :   
   50002             :   (void)builtin_pytype;
   50003             :   (void)builtin_base_count;
   50004             :   (void)builtin_basetype;
   50005             :   (void)tuple;
   50006             :   (void)static_getset;
   50007             :   (void)self;
   50008             :   
   50009             :   /* Metaclass is used to implement static member variables */
   50010             :   metatype = SwigPyObjectType();
   50011             :   assert(metatype);
   50012             : #endif
   50013             :   
   50014             :   /* Fix SwigMethods to carry the callback ptrs when needed */
   50015           1 :   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
   50016             :   
   50017             : #if PY_VERSION_HEX >= 0x03000000
   50018           1 :   m = PyModule_Create(&SWIG_module);
   50019             : #else
   50020             :   m = Py_InitModule((char *) SWIG_name, SwigMethods);
   50021             : #endif
   50022             :   
   50023           1 :   md = d = PyModule_GetDict(m);
   50024             :   (void)md;
   50025             :   
   50026           1 :   SWIG_InitializeModule(0);
   50027             :   
   50028             : #ifdef SWIGPYTHON_BUILTIN
   50029             :   swigpyobject = SwigPyObject_TypeOnce();
   50030             :   
   50031             :   SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
   50032             :   assert(SwigPyObject_stype);
   50033             :   cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
   50034             :   if (!cd) {
   50035             :     SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
   50036             :     SwigPyObject_clientdata.pytype = swigpyobject;
   50037             :   } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
   50038             :     PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
   50039             : # if PY_VERSION_HEX >= 0x03000000
   50040             :     return NULL;
   50041             : # else
   50042             :     return;
   50043             : # endif
   50044             :   }
   50045             :   
   50046             :   /* All objects have a 'this' attribute */
   50047             :   this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
   50048             :   (void)this_descr;
   50049             :   
   50050             :   /* All objects have a 'thisown' attribute */
   50051             :   thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
   50052             :   (void)thisown_descr;
   50053             :   
   50054             :   public_interface = PyList_New(0);
   50055             :   public_symbol = 0;
   50056             :   (void)public_symbol;
   50057             :   
   50058             :   PyDict_SetItemString(md, "__all__", public_interface);
   50059             :   Py_DECREF(public_interface);
   50060             :   for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
   50061             :   SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
   50062             :   for (i = 0; swig_const_table[i].name != 0; ++i)
   50063             :   SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
   50064             : #endif
   50065             :   
   50066           1 :   SWIG_InstallConstants(d,swig_const_table);
   50067             :   
   50068             :   
   50069             :   
   50070             :   /* See bug 1203 for discussion of race condition with GD font cache */
   50071           1 :   if (msSetup() != MS_SUCCESS)
   50072             :   {
   50073           0 :     msSetError(MS_MISCERR, "Failed to set up threads and font cache",
   50074             :       "msSetup()");
   50075             :   }
   50076             :   
   50077           1 :   Py_AtExit(msCleanup);
   50078             :   
   50079             :   /* Define Generic MapServer error */
   50080           1 :   MSExc_MapServerError=PyErr_NewException("_mapscript.MapServerError",NULL,NULL);
   50081           1 :   if (MSExc_MapServerError != NULL)
   50082           1 :   PyDict_SetItemString(d, "MapServerError", MSExc_MapServerError);
   50083             :   
   50084             :   /* Define MapServer MS_CHILD error */
   50085           1 :   MSExc_MapServerChildError = PyErr_NewException("_mapscript.MapServerChildError", NULL, NULL);
   50086           1 :   if (MSExc_MapServerChildError != NULL)
   50087           1 :   PyDict_SetItemString(d, "MapServerChildError", MSExc_MapServerChildError);
   50088             :   
   50089             :   
   50090           1 :   SWIG_Python_SetConstant(d, "MS_TRUE",SWIG_From_int((int)(1)));
   50091           1 :   SWIG_Python_SetConstant(d, "MS_FALSE",SWIG_From_int((int)(0)));
   50092           1 :   SWIG_Python_SetConstant(d, "MS_UNKNOWN",SWIG_From_int((int)(-1)));
   50093           1 :   SWIG_Python_SetConstant(d, "MS_ON",SWIG_From_int((int)(1)));
   50094           1 :   SWIG_Python_SetConstant(d, "MS_OFF",SWIG_From_int((int)(0)));
   50095           1 :   SWIG_Python_SetConstant(d, "MS_DEFAULT",SWIG_From_int((int)(2)));
   50096           1 :   SWIG_Python_SetConstant(d, "MS_EMBED",SWIG_From_int((int)(3)));
   50097           1 :   SWIG_Python_SetConstant(d, "MS_DELETE",SWIG_From_int((int)(4)));
   50098           1 :   SWIG_Python_SetConstant(d, "MS_YES",SWIG_From_int((int)(1)));
   50099           1 :   SWIG_Python_SetConstant(d, "MS_NO",SWIG_From_int((int)(0)));
   50100           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_ALLOCSIZE",SWIG_From_int((int)(64)));
   50101           1 :   SWIG_Python_SetConstant(d, "MS_CLASS_ALLOCSIZE",SWIG_From_int((int)(8)));
   50102           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_ALLOCSIZE",SWIG_From_int((int)(4)));
   50103           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_ALLOCSIZE",SWIG_From_int((int)(2)));
   50104           1 :   SWIG_Python_SetConstant(d, "MS_MAX_LABEL_PRIORITY",SWIG_From_int((int)(10)));
   50105           1 :   SWIG_Python_SetConstant(d, "MS_MAX_LABEL_FONTS",SWIG_From_int((int)(5)));
   50106           1 :   SWIG_Python_SetConstant(d, "MS_DEFAULT_LABEL_PRIORITY",SWIG_From_int((int)(1)));
   50107           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_FORCE_GROUP",SWIG_From_int((int)(2)));
   50108           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_SWF",SWIG_From_int((int)(2)));
   50109           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_RAWDATA",SWIG_From_int((int)(3)));
   50110           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_IMAGEMAP",SWIG_From_int((int)(5)));
   50111           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_TEMPLATE",SWIG_From_int((int)(8)));
   50112           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_OGR",SWIG_From_int((int)(16)));
   50113           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_PLUGIN",SWIG_From_int((int)(100)));
   50114           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_CAIRO_RASTER",SWIG_From_int((int)(101)));
   50115           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_CAIRO_PDF",SWIG_From_int((int)(102)));
   50116           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_CAIRO_SVG",SWIG_From_int((int)(103)));
   50117           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_OGL",SWIG_From_int((int)(104)));
   50118           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_AGG",SWIG_From_int((int)(105)));
   50119           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_KML",SWIG_From_int((int)(106)));
   50120           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_UTFGRID",SWIG_From_int((int)(107)));
   50121           1 :   SWIG_Python_SetConstant(d, "MS_RENDER_WITH_MVT",SWIG_From_int((int)(108)));
   50122           1 :   SWIG_Python_SetConstant(d, "MS_FILE_MAP",SWIG_From_int((int)(MS_FILE_MAP)));
   50123           1 :   SWIG_Python_SetConstant(d, "MS_FILE_SYMBOL",SWIG_From_int((int)(MS_FILE_SYMBOL)));
   50124           1 :   SWIG_Python_SetConstant(d, "MS_INCHES",SWIG_From_int((int)(MS_INCHES)));
   50125           1 :   SWIG_Python_SetConstant(d, "MS_FEET",SWIG_From_int((int)(MS_FEET)));
   50126           1 :   SWIG_Python_SetConstant(d, "MS_MILES",SWIG_From_int((int)(MS_MILES)));
   50127           1 :   SWIG_Python_SetConstant(d, "MS_METERS",SWIG_From_int((int)(MS_METERS)));
   50128           1 :   SWIG_Python_SetConstant(d, "MS_KILOMETERS",SWIG_From_int((int)(MS_KILOMETERS)));
   50129           1 :   SWIG_Python_SetConstant(d, "MS_DD",SWIG_From_int((int)(MS_DD)));
   50130           1 :   SWIG_Python_SetConstant(d, "MS_PIXELS",SWIG_From_int((int)(MS_PIXELS)));
   50131           1 :   SWIG_Python_SetConstant(d, "MS_PERCENTAGES",SWIG_From_int((int)(MS_PERCENTAGES)));
   50132           1 :   SWIG_Python_SetConstant(d, "MS_NAUTICALMILES",SWIG_From_int((int)(MS_NAUTICALMILES)));
   50133           1 :   SWIG_Python_SetConstant(d, "MS_INHERIT",SWIG_From_int((int)(MS_INHERIT)));
   50134           1 :   SWIG_Python_SetConstant(d, "MS_SHAPE_POINT",SWIG_From_int((int)(MS_SHAPE_POINT)));
   50135           1 :   SWIG_Python_SetConstant(d, "MS_SHAPE_LINE",SWIG_From_int((int)(MS_SHAPE_LINE)));
   50136           1 :   SWIG_Python_SetConstant(d, "MS_SHAPE_POLYGON",SWIG_From_int((int)(MS_SHAPE_POLYGON)));
   50137           1 :   SWIG_Python_SetConstant(d, "MS_SHAPE_NULL",SWIG_From_int((int)(MS_SHAPE_NULL)));
   50138           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_POINT",SWIG_From_int((int)(MS_LAYER_POINT)));
   50139           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_LINE",SWIG_From_int((int)(MS_LAYER_LINE)));
   50140           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_POLYGON",SWIG_From_int((int)(MS_LAYER_POLYGON)));
   50141           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_RASTER",SWIG_From_int((int)(MS_LAYER_RASTER)));
   50142           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_ANNOTATION",SWIG_From_int((int)(MS_LAYER_ANNOTATION)));
   50143           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_QUERY",SWIG_From_int((int)(MS_LAYER_QUERY)));
   50144           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_CIRCLE",SWIG_From_int((int)(MS_LAYER_CIRCLE)));
   50145           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_TILEINDEX",SWIG_From_int((int)(MS_LAYER_TILEINDEX)));
   50146           1 :   SWIG_Python_SetConstant(d, "MS_LAYER_CHART",SWIG_From_int((int)(MS_LAYER_CHART)));
   50147           1 :   SWIG_Python_SetConstant(d, "MS_TRUETYPE",SWIG_From_int((int)(MS_TRUETYPE)));
   50148           1 :   SWIG_Python_SetConstant(d, "MS_BITMAP",SWIG_From_int((int)(MS_BITMAP)));
   50149           1 :   SWIG_Python_SetConstant(d, "MS_FIRST_MATCHING_CLASS",SWIG_From_int((int)(MS_FIRST_MATCHING_CLASS)));
   50150           1 :   SWIG_Python_SetConstant(d, "MS_ALL_MATCHING_CLASSES",SWIG_From_int((int)(MS_ALL_MATCHING_CLASSES)));
   50151           1 :   SWIG_Python_SetConstant(d, "MS_POSITIONS_LENGTH",SWIG_From_int((int)(14)));
   50152           1 :   SWIG_Python_SetConstant(d, "MS_UL",SWIG_From_int((int)(MS_UL)));
   50153           1 :   SWIG_Python_SetConstant(d, "MS_LR",SWIG_From_int((int)(MS_LR)));
   50154           1 :   SWIG_Python_SetConstant(d, "MS_UR",SWIG_From_int((int)(MS_UR)));
   50155           1 :   SWIG_Python_SetConstant(d, "MS_LL",SWIG_From_int((int)(MS_LL)));
   50156           1 :   SWIG_Python_SetConstant(d, "MS_CR",SWIG_From_int((int)(MS_CR)));
   50157           1 :   SWIG_Python_SetConstant(d, "MS_CL",SWIG_From_int((int)(MS_CL)));
   50158           1 :   SWIG_Python_SetConstant(d, "MS_UC",SWIG_From_int((int)(MS_UC)));
   50159           1 :   SWIG_Python_SetConstant(d, "MS_LC",SWIG_From_int((int)(MS_LC)));
   50160           1 :   SWIG_Python_SetConstant(d, "MS_CC",SWIG_From_int((int)(MS_CC)));
   50161           1 :   SWIG_Python_SetConstant(d, "MS_AUTO",SWIG_From_int((int)(MS_AUTO)));
   50162           1 :   SWIG_Python_SetConstant(d, "MS_XY",SWIG_From_int((int)(MS_XY)));
   50163           1 :   SWIG_Python_SetConstant(d, "MS_NONE",SWIG_From_int((int)(MS_NONE)));
   50164           1 :   SWIG_Python_SetConstant(d, "MS_AUTO2",SWIG_From_int((int)(MS_AUTO2)));
   50165           1 :   SWIG_Python_SetConstant(d, "MS_FOLLOW",SWIG_From_int((int)(MS_FOLLOW)));
   50166           1 :   SWIG_Python_SetConstant(d, "MS_TINY",SWIG_From_int((int)(5)));
   50167           1 :   SWIG_Python_SetConstant(d, "MS_SMALL",SWIG_From_int((int)(7)));
   50168           1 :   SWIG_Python_SetConstant(d, "MS_MEDIUM",SWIG_From_int((int)(10)));
   50169           1 :   SWIG_Python_SetConstant(d, "MS_LARGE",SWIG_From_int((int)(13)));
   50170           1 :   SWIG_Python_SetConstant(d, "MS_GIANT",SWIG_From_int((int)(16)));
   50171           1 :   SWIG_Python_SetConstant(d, "MS_NORMAL",SWIG_From_int((int)(MS_NORMAL)));
   50172           1 :   SWIG_Python_SetConstant(d, "MS_HILITE",SWIG_From_int((int)(MS_HILITE)));
   50173           1 :   SWIG_Python_SetConstant(d, "MS_SELECTED",SWIG_From_int((int)(MS_SELECTED)));
   50174           1 :   SWIG_Python_SetConstant(d, "MS_INLINE",SWIG_From_int((int)(MS_INLINE)));
   50175           1 :   SWIG_Python_SetConstant(d, "MS_SHAPEFILE",SWIG_From_int((int)(MS_SHAPEFILE)));
   50176           1 :   SWIG_Python_SetConstant(d, "MS_TILED_SHAPEFILE",SWIG_From_int((int)(MS_TILED_SHAPEFILE)));
   50177           1 :   SWIG_Python_SetConstant(d, "MS_UNUSED_2",SWIG_From_int((int)(MS_UNUSED_2)));
   50178           1 :   SWIG_Python_SetConstant(d, "MS_OGR",SWIG_From_int((int)(MS_OGR)));
   50179           1 :   SWIG_Python_SetConstant(d, "MS_UNUSED_1",SWIG_From_int((int)(MS_UNUSED_1)));
   50180           1 :   SWIG_Python_SetConstant(d, "MS_POSTGIS",SWIG_From_int((int)(MS_POSTGIS)));
   50181           1 :   SWIG_Python_SetConstant(d, "MS_WMS",SWIG_From_int((int)(MS_WMS)));
   50182           1 :   SWIG_Python_SetConstant(d, "MS_ORACLESPATIAL",SWIG_From_int((int)(MS_ORACLESPATIAL)));
   50183           1 :   SWIG_Python_SetConstant(d, "MS_WFS",SWIG_From_int((int)(MS_WFS)));
   50184           1 :   SWIG_Python_SetConstant(d, "MS_GRATICULE",SWIG_From_int((int)(MS_GRATICULE)));
   50185           1 :   SWIG_Python_SetConstant(d, "MS_MYSQL",SWIG_From_int((int)(MS_MYSQL)));
   50186           1 :   SWIG_Python_SetConstant(d, "MS_RASTER",SWIG_From_int((int)(MS_RASTER)));
   50187           1 :   SWIG_Python_SetConstant(d, "MS_PLUGIN",SWIG_From_int((int)(MS_PLUGIN)));
   50188           1 :   SWIG_Python_SetConstant(d, "MS_UNION",SWIG_From_int((int)(MS_UNION)));
   50189           1 :   SWIG_Python_SetConstant(d, "MS_UVRASTER",SWIG_From_int((int)(MS_UVRASTER)));
   50190           1 :   SWIG_Python_SetConstant(d, "MS_CONTOUR",SWIG_From_int((int)(MS_CONTOUR)));
   50191           1 :   SWIG_Python_SetConstant(d, "MS_KERNELDENSITY",SWIG_From_int((int)(MS_KERNELDENSITY)));
   50192           1 :   SWIG_Python_SetConstant(d, "MS_DB_XBASE",SWIG_From_int((int)(MS_DB_XBASE)));
   50193           1 :   SWIG_Python_SetConstant(d, "MS_DB_CSV",SWIG_From_int((int)(MS_DB_CSV)));
   50194           1 :   SWIG_Python_SetConstant(d, "MS_DB_MYSQL",SWIG_From_int((int)(MS_DB_MYSQL)));
   50195           1 :   SWIG_Python_SetConstant(d, "MS_DB_ORACLE",SWIG_From_int((int)(MS_DB_ORACLE)));
   50196           1 :   SWIG_Python_SetConstant(d, "MS_DB_POSTGRES",SWIG_From_int((int)(MS_DB_POSTGRES)));
   50197           1 :   SWIG_Python_SetConstant(d, "MS_JOIN_ONE_TO_ONE",SWIG_From_int((int)(MS_JOIN_ONE_TO_ONE)));
   50198           1 :   SWIG_Python_SetConstant(d, "MS_JOIN_ONE_TO_MANY",SWIG_From_int((int)(MS_JOIN_ONE_TO_MANY)));
   50199           1 :   SWIG_Python_SetConstant(d, "MS_SINGLE",SWIG_From_int((int)(0)));
   50200           1 :   SWIG_Python_SetConstant(d, "MS_MULTIPLE",SWIG_From_int((int)(1)));
   50201           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_SINGLE",SWIG_From_int((int)(MS_QUERY_SINGLE)));
   50202           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_MULTIPLE",SWIG_From_int((int)(MS_QUERY_MULTIPLE)));
   50203           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_IS_NULL",SWIG_From_int((int)(MS_QUERY_IS_NULL)));
   50204           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_BY_POINT",SWIG_From_int((int)(MS_QUERY_BY_POINT)));
   50205           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_BY_RECT",SWIG_From_int((int)(MS_QUERY_BY_RECT)));
   50206           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_BY_SHAPE",SWIG_From_int((int)(MS_QUERY_BY_SHAPE)));
   50207           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_BY_ATTRIBUTE",SWIG_From_int((int)(MS_QUERY_BY_ATTRIBUTE)));
   50208           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_BY_INDEX",SWIG_From_int((int)(MS_QUERY_BY_INDEX)));
   50209           1 :   SWIG_Python_SetConstant(d, "MS_QUERY_BY_FILTER",SWIG_From_int((int)(MS_QUERY_BY_FILTER)));
   50210           1 :   SWIG_Python_SetConstant(d, "MS_ALIGN_DEFAULT",SWIG_From_int((int)(MS_ALIGN_DEFAULT)));
   50211           1 :   SWIG_Python_SetConstant(d, "MS_ALIGN_LEFT",SWIG_From_int((int)(MS_ALIGN_LEFT)));
   50212           1 :   SWIG_Python_SetConstant(d, "MS_ALIGN_CENTER",SWIG_From_int((int)(MS_ALIGN_CENTER)));
   50213           1 :   SWIG_Python_SetConstant(d, "MS_ALIGN_RIGHT",SWIG_From_int((int)(MS_ALIGN_RIGHT)));
   50214           1 :   SWIG_Python_SetConstant(d, "MS_CJC_NONE",SWIG_From_int((int)(MS_CJC_NONE)));
   50215           1 :   SWIG_Python_SetConstant(d, "MS_CJC_BEVEL",SWIG_From_int((int)(MS_CJC_BEVEL)));
   50216           1 :   SWIG_Python_SetConstant(d, "MS_CJC_BUTT",SWIG_From_int((int)(MS_CJC_BUTT)));
   50217           1 :   SWIG_Python_SetConstant(d, "MS_CJC_MITER",SWIG_From_int((int)(MS_CJC_MITER)));
   50218           1 :   SWIG_Python_SetConstant(d, "MS_CJC_ROUND",SWIG_From_int((int)(MS_CJC_ROUND)));
   50219           1 :   SWIG_Python_SetConstant(d, "MS_CJC_SQUARE",SWIG_From_int((int)(MS_CJC_SQUARE)));
   50220           1 :   SWIG_Python_SetConstant(d, "MS_CJC_TRIANGLE",SWIG_From_int((int)(MS_CJC_TRIANGLE)));
   50221           1 :   SWIG_Python_SetConstant(d, "MS_CJC_DEFAULT_JOIN_MAXSIZE",SWIG_From_int((int)(3)));
   50222           1 :   SWIG_Python_SetConstant(d, "MS_SUCCESS",SWIG_From_int((int)(MS_SUCCESS)));
   50223           1 :   SWIG_Python_SetConstant(d, "MS_FAILURE",SWIG_From_int((int)(MS_FAILURE)));
   50224           1 :   SWIG_Python_SetConstant(d, "MS_DONE",SWIG_From_int((int)(MS_DONE)));
   50225           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_PC256",SWIG_From_int((int)(MS_IMAGEMODE_PC256)));
   50226           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_RGB",SWIG_From_int((int)(MS_IMAGEMODE_RGB)));
   50227           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_RGBA",SWIG_From_int((int)(MS_IMAGEMODE_RGBA)));
   50228           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_INT16",SWIG_From_int((int)(MS_IMAGEMODE_INT16)));
   50229           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_FLOAT32",SWIG_From_int((int)(MS_IMAGEMODE_FLOAT32)));
   50230           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_BYTE",SWIG_From_int((int)(MS_IMAGEMODE_BYTE)));
   50231           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_FEATURE",SWIG_From_int((int)(MS_IMAGEMODE_FEATURE)));
   50232           1 :   SWIG_Python_SetConstant(d, "MS_IMAGEMODE_NULL",SWIG_From_int((int)(MS_IMAGEMODE_NULL)));
   50233           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_EQUALS",SWIG_From_int((int)(MS_GEOS_EQUALS)));
   50234           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_DISJOINT",SWIG_From_int((int)(MS_GEOS_DISJOINT)));
   50235           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_TOUCHES",SWIG_From_int((int)(MS_GEOS_TOUCHES)));
   50236           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_OVERLAPS",SWIG_From_int((int)(MS_GEOS_OVERLAPS)));
   50237           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_CROSSES",SWIG_From_int((int)(MS_GEOS_CROSSES)));
   50238           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_INTERSECTS",SWIG_From_int((int)(MS_GEOS_INTERSECTS)));
   50239           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_WITHIN",SWIG_From_int((int)(MS_GEOS_WITHIN)));
   50240           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_CONTAINS",SWIG_From_int((int)(MS_GEOS_CONTAINS)));
   50241           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_BEYOND",SWIG_From_int((int)(MS_GEOS_BEYOND)));
   50242           1 :   SWIG_Python_SetConstant(d, "MS_GEOS_DWITHIN",SWIG_From_int((int)(MS_GEOS_DWITHIN)));
   50243           1 :   SWIG_Python_SetConstant(d, "MS_TRANSFORM_NONE",SWIG_From_int((int)(MS_TRANSFORM_NONE)));
   50244           1 :   SWIG_Python_SetConstant(d, "MS_TRANSFORM_ROUND",SWIG_From_int((int)(MS_TRANSFORM_ROUND)));
   50245           1 :   SWIG_Python_SetConstant(d, "MS_TRANSFORM_SNAPTOGRID",SWIG_From_int((int)(MS_TRANSFORM_SNAPTOGRID)));
   50246           1 :   SWIG_Python_SetConstant(d, "MS_TRANSFORM_FULLRESOLUTION",SWIG_From_int((int)(MS_TRANSFORM_FULLRESOLUTION)));
   50247           1 :   SWIG_Python_SetConstant(d, "MS_TRANSFORM_SIMPLIFY",SWIG_From_int((int)(MS_TRANSFORM_SIMPLIFY)));
   50248           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_CLEAR",SWIG_From_int((int)(MS_COMPOP_CLEAR)));
   50249           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SRC",SWIG_From_int((int)(MS_COMPOP_SRC)));
   50250           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DST",SWIG_From_int((int)(MS_COMPOP_DST)));
   50251           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_OVER",SWIG_From_int((int)(MS_COMPOP_SRC_OVER)));
   50252           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DST_OVER",SWIG_From_int((int)(MS_COMPOP_DST_OVER)));
   50253           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_IN",SWIG_From_int((int)(MS_COMPOP_SRC_IN)));
   50254           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DST_IN",SWIG_From_int((int)(MS_COMPOP_DST_IN)));
   50255           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_OUT",SWIG_From_int((int)(MS_COMPOP_SRC_OUT)));
   50256           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DST_OUT",SWIG_From_int((int)(MS_COMPOP_DST_OUT)));
   50257           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_ATOP",SWIG_From_int((int)(MS_COMPOP_SRC_ATOP)));
   50258           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DST_ATOP",SWIG_From_int((int)(MS_COMPOP_DST_ATOP)));
   50259           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_XOR",SWIG_From_int((int)(MS_COMPOP_XOR)));
   50260           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_PLUS",SWIG_From_int((int)(MS_COMPOP_PLUS)));
   50261           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_MINUS",SWIG_From_int((int)(MS_COMPOP_MINUS)));
   50262           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_MULTIPLY",SWIG_From_int((int)(MS_COMPOP_MULTIPLY)));
   50263           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SCREEN",SWIG_From_int((int)(MS_COMPOP_SCREEN)));
   50264           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_OVERLAY",SWIG_From_int((int)(MS_COMPOP_OVERLAY)));
   50265           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DARKEN",SWIG_From_int((int)(MS_COMPOP_DARKEN)));
   50266           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_LIGHTEN",SWIG_From_int((int)(MS_COMPOP_LIGHTEN)));
   50267           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_COLOR_DODGE",SWIG_From_int((int)(MS_COMPOP_COLOR_DODGE)));
   50268           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_COLOR_BURN",SWIG_From_int((int)(MS_COMPOP_COLOR_BURN)));
   50269           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_HARD_LIGHT",SWIG_From_int((int)(MS_COMPOP_HARD_LIGHT)));
   50270           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_SOFT_LIGHT",SWIG_From_int((int)(MS_COMPOP_SOFT_LIGHT)));
   50271           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_DIFFERENCE",SWIG_From_int((int)(MS_COMPOP_DIFFERENCE)));
   50272           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_EXCLUSION",SWIG_From_int((int)(MS_COMPOP_EXCLUSION)));
   50273           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_CONTRAST",SWIG_From_int((int)(MS_COMPOP_CONTRAST)));
   50274           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_INVERT",SWIG_From_int((int)(MS_COMPOP_INVERT)));
   50275           1 :   SWIG_Python_SetConstant(d, "MS_COMPOP_INVERT_RGB",SWIG_From_int((int)(MS_COMPOP_INVERT_RGB)));
   50276           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_LENGTH",SWIG_From_int((int)(12)));
   50277           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_SIZE",SWIG_From_int((int)(MS_STYLE_BINDING_SIZE)));
   50278           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_WIDTH",SWIG_From_int((int)(MS_STYLE_BINDING_WIDTH)));
   50279           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_ANGLE",SWIG_From_int((int)(MS_STYLE_BINDING_ANGLE)));
   50280           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_COLOR",SWIG_From_int((int)(MS_STYLE_BINDING_COLOR)));
   50281           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OUTLINECOLOR",SWIG_From_int((int)(MS_STYLE_BINDING_OUTLINECOLOR)));
   50282           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_SYMBOL",SWIG_From_int((int)(MS_STYLE_BINDING_SYMBOL)));
   50283           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OUTLINEWIDTH",SWIG_From_int((int)(MS_STYLE_BINDING_OUTLINEWIDTH)));
   50284           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OPACITY",SWIG_From_int((int)(MS_STYLE_BINDING_OPACITY)));
   50285           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OFFSET_X",SWIG_From_int((int)(MS_STYLE_BINDING_OFFSET_X)));
   50286           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OFFSET_Y",SWIG_From_int((int)(MS_STYLE_BINDING_OFFSET_Y)));
   50287           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_POLAROFFSET_PIXEL",SWIG_From_int((int)(MS_STYLE_BINDING_POLAROFFSET_PIXEL)));
   50288           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_POLAROFFSET_ANGLE",SWIG_From_int((int)(MS_STYLE_BINDING_POLAROFFSET_ANGLE)));
   50289           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_LENGTH",SWIG_From_int((int)(12)));
   50290           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_SIZE",SWIG_From_int((int)(MS_LABEL_BINDING_SIZE)));
   50291           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_ANGLE",SWIG_From_int((int)(MS_LABEL_BINDING_ANGLE)));
   50292           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_COLOR",SWIG_From_int((int)(MS_LABEL_BINDING_COLOR)));
   50293           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_OUTLINECOLOR",SWIG_From_int((int)(MS_LABEL_BINDING_OUTLINECOLOR)));
   50294           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_FONT",SWIG_From_int((int)(MS_LABEL_BINDING_FONT)));
   50295           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_PRIORITY",SWIG_From_int((int)(MS_LABEL_BINDING_PRIORITY)));
   50296           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_POSITION",SWIG_From_int((int)(MS_LABEL_BINDING_POSITION)));
   50297           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_SHADOWSIZEX",SWIG_From_int((int)(MS_LABEL_BINDING_SHADOWSIZEX)));
   50298           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_SHADOWSIZEY",SWIG_From_int((int)(MS_LABEL_BINDING_SHADOWSIZEY)));
   50299           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_OFFSET_X",SWIG_From_int((int)(MS_LABEL_BINDING_OFFSET_X)));
   50300           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_OFFSET_Y",SWIG_From_int((int)(MS_LABEL_BINDING_OFFSET_Y)));
   50301           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_ALIGN",SWIG_From_int((int)(MS_LABEL_BINDING_ALIGN)));
   50302           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LOGICAL_AND",SWIG_From_int((int)(MS_TOKEN_LOGICAL_AND)));
   50303           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LOGICAL_OR",SWIG_From_int((int)(MS_TOKEN_LOGICAL_OR)));
   50304           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LOGICAL_NOT",SWIG_From_int((int)(MS_TOKEN_LOGICAL_NOT)));
   50305           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_NUMBER",SWIG_From_int((int)(MS_TOKEN_LITERAL_NUMBER)));
   50306           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_STRING",SWIG_From_int((int)(MS_TOKEN_LITERAL_STRING)));
   50307           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_TIME",SWIG_From_int((int)(MS_TOKEN_LITERAL_TIME)));
   50308           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_SHAPE",SWIG_From_int((int)(MS_TOKEN_LITERAL_SHAPE)));
   50309           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_BOOLEAN",SWIG_From_int((int)(MS_TOKEN_LITERAL_BOOLEAN)));
   50310           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_EQ",SWIG_From_int((int)(MS_TOKEN_COMPARISON_EQ)));
   50311           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_NE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_NE)));
   50312           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_GT",SWIG_From_int((int)(MS_TOKEN_COMPARISON_GT)));
   50313           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_LT",SWIG_From_int((int)(MS_TOKEN_COMPARISON_LT)));
   50314           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_LE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_LE)));
   50315           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_GE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_GE)));
   50316           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_IEQ",SWIG_From_int((int)(MS_TOKEN_COMPARISON_IEQ)));
   50317           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_RE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_RE)));
   50318           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_IRE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_IRE)));
   50319           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_IN",SWIG_From_int((int)(MS_TOKEN_COMPARISON_IN)));
   50320           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_LIKE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_LIKE)));
   50321           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_INTERSECTS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_INTERSECTS)));
   50322           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_DISJOINT",SWIG_From_int((int)(MS_TOKEN_COMPARISON_DISJOINT)));
   50323           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_TOUCHES",SWIG_From_int((int)(MS_TOKEN_COMPARISON_TOUCHES)));
   50324           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_OVERLAPS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_OVERLAPS)));
   50325           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_CROSSES",SWIG_From_int((int)(MS_TOKEN_COMPARISON_CROSSES)));
   50326           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_WITHIN",SWIG_From_int((int)(MS_TOKEN_COMPARISON_WITHIN)));
   50327           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_CONTAINS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_CONTAINS)));
   50328           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_EQUALS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_EQUALS)));
   50329           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_BEYOND",SWIG_From_int((int)(MS_TOKEN_COMPARISON_BEYOND)));
   50330           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_DWITHIN",SWIG_From_int((int)(MS_TOKEN_COMPARISON_DWITHIN)));
   50331           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_LENGTH",SWIG_From_int((int)(MS_TOKEN_FUNCTION_LENGTH)));
   50332           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_TOSTRING",SWIG_From_int((int)(MS_TOKEN_FUNCTION_TOSTRING)));
   50333           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_COMMIFY",SWIG_From_int((int)(MS_TOKEN_FUNCTION_COMMIFY)));
   50334           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_AREA",SWIG_From_int((int)(MS_TOKEN_FUNCTION_AREA)));
   50335           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_ROUND",SWIG_From_int((int)(MS_TOKEN_FUNCTION_ROUND)));
   50336           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_FROMTEXT",SWIG_From_int((int)(MS_TOKEN_FUNCTION_FROMTEXT)));
   50337           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_BUFFER",SWIG_From_int((int)(MS_TOKEN_FUNCTION_BUFFER)));
   50338           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_DIFFERENCE",SWIG_From_int((int)(MS_TOKEN_FUNCTION_DIFFERENCE)));
   50339           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_SIMPLIFY",SWIG_From_int((int)(MS_TOKEN_FUNCTION_SIMPLIFY)));
   50340           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_SIMPLIFYPT",SWIG_From_int((int)(MS_TOKEN_FUNCTION_SIMPLIFYPT)));
   50341           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_GENERALIZE",SWIG_From_int((int)(MS_TOKEN_FUNCTION_GENERALIZE)));
   50342           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_SMOOTHSIA",SWIG_From_int((int)(MS_TOKEN_FUNCTION_SMOOTHSIA)));
   50343           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_JAVASCRIPT",SWIG_From_int((int)(MS_TOKEN_FUNCTION_JAVASCRIPT)));
   50344           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_UPPER",SWIG_From_int((int)(MS_TOKEN_FUNCTION_UPPER)));
   50345           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_LOWER",SWIG_From_int((int)(MS_TOKEN_FUNCTION_LOWER)));
   50346           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_INITCAP",SWIG_From_int((int)(MS_TOKEN_FUNCTION_INITCAP)));
   50347           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_FIRSTCAP",SWIG_From_int((int)(MS_TOKEN_FUNCTION_FIRSTCAP)));
   50348           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_DOUBLE",SWIG_From_int((int)(MS_TOKEN_BINDING_DOUBLE)));
   50349           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_INTEGER",SWIG_From_int((int)(MS_TOKEN_BINDING_INTEGER)));
   50350           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_STRING",SWIG_From_int((int)(MS_TOKEN_BINDING_STRING)));
   50351           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_TIME",SWIG_From_int((int)(MS_TOKEN_BINDING_TIME)));
   50352           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_SHAPE",SWIG_From_int((int)(MS_TOKEN_BINDING_SHAPE)));
   50353           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_MAP_CELLSIZE",SWIG_From_int((int)(MS_TOKEN_BINDING_MAP_CELLSIZE)));
   50354           1 :   SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_DATA_CELLSIZE",SWIG_From_int((int)(MS_TOKEN_BINDING_DATA_CELLSIZE)));
   50355           1 :   SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_BOOLEAN",SWIG_From_int((int)(MS_PARSE_TYPE_BOOLEAN)));
   50356           1 :   SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_STRING",SWIG_From_int((int)(MS_PARSE_TYPE_STRING)));
   50357           1 :   SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_SHAPE",SWIG_From_int((int)(MS_PARSE_TYPE_SHAPE)));
   50358           1 :   SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_SLD",SWIG_From_int((int)(MS_PARSE_TYPE_SLD)));
   50359           1 :   SWIG_Python_SetConstant(d, "MS_NOOVERRIDE",SWIG_From_int((int)(-1111)));
   50360           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_SINGLE_SIDED_OFFSET",SWIG_From_int((int)(-99)));
   50361           1 :   SWIG_Python_SetConstant(d, "MS_STYLE_DOUBLE_SIDED_OFFSET",SWIG_From_int((int)(-999)));
   50362           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_PERPENDICULAR_OFFSET",SWIG_From_int((int)(-99)));
   50363           1 :   SWIG_Python_SetConstant(d, "MS_LABEL_PERPENDICULAR_TOP_OFFSET",SWIG_From_int((int)(99)));
   50364           1 :   SWIG_Python_SetConstant(d, "MS_VERSION_MAJOR",SWIG_From_int((int)(7)));
   50365           1 :   SWIG_Python_SetConstant(d, "MS_VERSION_MINOR",SWIG_From_int((int)(7)));
   50366           1 :   SWIG_Python_SetConstant(d, "MS_VERSION_REV",SWIG_From_int((int)(0)));
   50367           1 :   SWIG_Python_SetConstant(d, "MS_VERSION",SWIG_FromCharPtr("7.7-dev"));
   50368           1 :   SWIG_Python_SetConstant(d, "MS_VERSION_NUM",SWIG_From_int((int)(70700)));
   50369           1 :   SWIG_Python_SetConstant(d, "MS_NOERR",SWIG_From_int((int)(0)));
   50370           1 :   SWIG_Python_SetConstant(d, "MS_IOERR",SWIG_From_int((int)(1)));
   50371           1 :   SWIG_Python_SetConstant(d, "MS_MEMERR",SWIG_From_int((int)(2)));
   50372           1 :   SWIG_Python_SetConstant(d, "MS_TYPEERR",SWIG_From_int((int)(3)));
   50373           1 :   SWIG_Python_SetConstant(d, "MS_SYMERR",SWIG_From_int((int)(4)));
   50374           1 :   SWIG_Python_SetConstant(d, "MS_REGEXERR",SWIG_From_int((int)(5)));
   50375           1 :   SWIG_Python_SetConstant(d, "MS_TTFERR",SWIG_From_int((int)(6)));
   50376           1 :   SWIG_Python_SetConstant(d, "MS_DBFERR",SWIG_From_int((int)(7)));
   50377           1 :   SWIG_Python_SetConstant(d, "MS_IDENTERR",SWIG_From_int((int)(9)));
   50378           1 :   SWIG_Python_SetConstant(d, "MS_EOFERR",SWIG_From_int((int)(10)));
   50379           1 :   SWIG_Python_SetConstant(d, "MS_PROJERR",SWIG_From_int((int)(11)));
   50380           1 :   SWIG_Python_SetConstant(d, "MS_MISCERR",SWIG_From_int((int)(12)));
   50381           1 :   SWIG_Python_SetConstant(d, "MS_CGIERR",SWIG_From_int((int)(13)));
   50382           1 :   SWIG_Python_SetConstant(d, "MS_WEBERR",SWIG_From_int((int)(14)));
   50383           1 :   SWIG_Python_SetConstant(d, "MS_IMGERR",SWIG_From_int((int)(15)));
   50384           1 :   SWIG_Python_SetConstant(d, "MS_HASHERR",SWIG_From_int((int)(16)));
   50385           1 :   SWIG_Python_SetConstant(d, "MS_JOINERR",SWIG_From_int((int)(17)));
   50386           1 :   SWIG_Python_SetConstant(d, "MS_NOTFOUND",SWIG_From_int((int)(18)));
   50387           1 :   SWIG_Python_SetConstant(d, "MS_SHPERR",SWIG_From_int((int)(19)));
   50388           1 :   SWIG_Python_SetConstant(d, "MS_PARSEERR",SWIG_From_int((int)(20)));
   50389           1 :   SWIG_Python_SetConstant(d, "MS_UNUSEDERR",SWIG_From_int((int)(21)));
   50390           1 :   SWIG_Python_SetConstant(d, "MS_OGRERR",SWIG_From_int((int)(22)));
   50391           1 :   SWIG_Python_SetConstant(d, "MS_QUERYERR",SWIG_From_int((int)(23)));
   50392           1 :   SWIG_Python_SetConstant(d, "MS_WMSERR",SWIG_From_int((int)(24)));
   50393           1 :   SWIG_Python_SetConstant(d, "MS_WMSCONNERR",SWIG_From_int((int)(25)));
   50394           1 :   SWIG_Python_SetConstant(d, "MS_ORACLESPATIALERR",SWIG_From_int((int)(26)));
   50395           1 :   SWIG_Python_SetConstant(d, "MS_WFSERR",SWIG_From_int((int)(27)));
   50396           1 :   SWIG_Python_SetConstant(d, "MS_WFSCONNERR",SWIG_From_int((int)(28)));
   50397           1 :   SWIG_Python_SetConstant(d, "MS_MAPCONTEXTERR",SWIG_From_int((int)(29)));
   50398           1 :   SWIG_Python_SetConstant(d, "MS_HTTPERR",SWIG_From_int((int)(30)));
   50399           1 :   SWIG_Python_SetConstant(d, "MS_CHILDERR",SWIG_From_int((int)(31)));
   50400           1 :   SWIG_Python_SetConstant(d, "MS_WCSERR",SWIG_From_int((int)(32)));
   50401           1 :   SWIG_Python_SetConstant(d, "MS_GEOSERR",SWIG_From_int((int)(33)));
   50402           1 :   SWIG_Python_SetConstant(d, "MS_RECTERR",SWIG_From_int((int)(34)));
   50403           1 :   SWIG_Python_SetConstant(d, "MS_TIMEERR",SWIG_From_int((int)(35)));
   50404           1 :   SWIG_Python_SetConstant(d, "MS_GMLERR",SWIG_From_int((int)(36)));
   50405           1 :   SWIG_Python_SetConstant(d, "MS_SOSERR",SWIG_From_int((int)(37)));
   50406           1 :   SWIG_Python_SetConstant(d, "MS_NULLPARENTERR",SWIG_From_int((int)(38)));
   50407           1 :   SWIG_Python_SetConstant(d, "MS_AGGERR",SWIG_From_int((int)(39)));
   50408           1 :   SWIG_Python_SetConstant(d, "MS_OWSERR",SWIG_From_int((int)(40)));
   50409           1 :   SWIG_Python_SetConstant(d, "MS_OGLERR",SWIG_From_int((int)(41)));
   50410           1 :   SWIG_Python_SetConstant(d, "MS_RENDERERERR",SWIG_From_int((int)(42)));
   50411           1 :   SWIG_Python_SetConstant(d, "MS_V8ERR",SWIG_From_int((int)(43)));
   50412           1 :   SWIG_Python_SetConstant(d, "MS_NUMERRORCODES",SWIG_From_int((int)(44)));
   50413           1 :   SWIG_Python_SetConstant(d, "MESSAGELENGTH",SWIG_From_int((int)(2048)));
   50414           1 :   SWIG_Python_SetConstant(d, "ROUTINELENGTH",SWIG_From_int((int)(64)));
   50415           1 :   SWIG_Python_SetConstant(d, "MS_ERROR_LANGUAGE",SWIG_FromCharPtr("en-US"));
   50416           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_ERRORSONLY",SWIG_From_int((int)(MS_DEBUGLEVEL_ERRORSONLY)));
   50417           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_DEBUG",SWIG_From_int((int)(MS_DEBUGLEVEL_DEBUG)));
   50418           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_TUNING",SWIG_From_int((int)(MS_DEBUGLEVEL_TUNING)));
   50419           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_V",SWIG_From_int((int)(MS_DEBUGLEVEL_V)));
   50420           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_VV",SWIG_From_int((int)(MS_DEBUGLEVEL_VV)));
   50421           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_VVV",SWIG_From_int((int)(MS_DEBUGLEVEL_VVV)));
   50422           1 :   SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_DEVDEBUG",SWIG_From_int((int)(MS_DEBUGLEVEL_DEVDEBUG)));
   50423           1 :   SWIG_Python_SetConstant(d, "SHX_BUFFER_PAGE",SWIG_From_int((int)(1024)));
   50424           1 :   SWIG_Python_SetConstant(d, "MS_SHAPEFILE_POINT",SWIG_From_int((int)(1)));
   50425           1 :   SWIG_Python_SetConstant(d, "MS_SHAPEFILE_ARC",SWIG_From_int((int)(3)));
   50426           1 :   SWIG_Python_SetConstant(d, "MS_SHAPEFILE_POLYGON",SWIG_From_int((int)(5)));
   50427           1 :   SWIG_Python_SetConstant(d, "MS_SHAPEFILE_MULTIPOINT",SWIG_From_int((int)(8)));
   50428           1 :   SWIG_Python_SetConstant(d, "MS_SHP_POINTZ",SWIG_From_int((int)(11)));
   50429           1 :   SWIG_Python_SetConstant(d, "MS_SHP_ARCZ",SWIG_From_int((int)(13)));
   50430           1 :   SWIG_Python_SetConstant(d, "MS_SHP_POLYGONZ",SWIG_From_int((int)(15)));
   50431           1 :   SWIG_Python_SetConstant(d, "MS_SHP_MULTIPOINTZ",SWIG_From_int((int)(18)));
   50432           1 :   SWIG_Python_SetConstant(d, "MS_SHP_POINTM",SWIG_From_int((int)(21)));
   50433           1 :   SWIG_Python_SetConstant(d, "MS_SHP_ARCM",SWIG_From_int((int)(23)));
   50434           1 :   SWIG_Python_SetConstant(d, "MS_SHP_POLYGONM",SWIG_From_int((int)(25)));
   50435           1 :   SWIG_Python_SetConstant(d, "MS_SHP_MULTIPOINTM",SWIG_From_int((int)(28)));
   50436           1 :   SWIG_Python_SetConstant(d, "FTString",SWIG_From_int((int)(FTString)));
   50437           1 :   SWIG_Python_SetConstant(d, "FTInteger",SWIG_From_int((int)(FTInteger)));
   50438           1 :   SWIG_Python_SetConstant(d, "FTDouble",SWIG_From_int((int)(FTDouble)));
   50439           1 :   SWIG_Python_SetConstant(d, "FTInvalid",SWIG_From_int((int)(FTInvalid)));
   50440           1 :   SWIG_Python_SetConstant(d, "wkp_none",SWIG_From_int((int)(0)));
   50441           1 :   SWIG_Python_SetConstant(d, "wkp_lonlat",SWIG_From_int((int)(1)));
   50442           1 :   SWIG_Python_SetConstant(d, "wkp_gmerc",SWIG_From_int((int)(2)));
   50443           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_SIMPLE",SWIG_From_int((int)(MS_SYMBOL_SIMPLE)));
   50444           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_VECTOR",SWIG_From_int((int)(MS_SYMBOL_VECTOR)));
   50445           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_ELLIPSE",SWIG_From_int((int)(MS_SYMBOL_ELLIPSE)));
   50446           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_PIXMAP",SWIG_From_int((int)(MS_SYMBOL_PIXMAP)));
   50447           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_TRUETYPE",SWIG_From_int((int)(MS_SYMBOL_TRUETYPE)));
   50448           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_HATCH",SWIG_From_int((int)(MS_SYMBOL_HATCH)));
   50449           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_SVG",SWIG_From_int((int)(MS_SYMBOL_SVG)));
   50450           1 :   SWIG_Python_SetConstant(d, "MS_SYMBOL_ALLOCSIZE",SWIG_From_int((int)(64)));
   50451           1 :   SWIG_Python_SetConstant(d, "MS_MAXVECTORPOINTS",SWIG_From_int((int)(100)));
   50452           1 :   SWIG_Python_SetConstant(d, "MS_MAXPATTERNLENGTH",SWIG_From_int((int)(10)));
   50453           1 :   SWIG_Python_SetConstant(d, "MS_IMAGECACHESIZE",SWIG_From_int((int)(6)));
   50454           1 :   SWIG_Python_SetConstant(d, "MS_HASHSIZE",SWIG_From_int((int)(41)));
   50455           1 :   SWIG_Python_SetConstant(d, "MS_DEFAULT_CGI_PARAMS",SWIG_From_int((int)(100)));
   50456           1 :   SWIG_Python_SetConstant(d, "MS_GET_REQUEST",SWIG_From_int((int)(MS_GET_REQUEST)));
   50457           1 :   SWIG_Python_SetConstant(d, "MS_POST_REQUEST",SWIG_From_int((int)(MS_POST_REQUEST)));
   50458             : #if PY_VERSION_HEX >= 0x03000000
   50459           1 :   return m;
   50460             : #else
   50461             :   return;
   50462             : #endif
   50463             : }
   50464             : 

Generated by: LCOV version 1.13